var GraphiQLSubscriptionsFetcher =
  /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/
  var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/
  function __webpack_require__(moduleId) {
    /******/
    /******/ 		// Check if module is in cache
    /******/
    if (installedModules[ moduleId ])
    /******/      return installedModules[ moduleId ].exports;
    /******/
    /******/ 		// Create a new module (and put it into the cache)
    /******/
    var module = installedModules[ moduleId ] = {
      /******/      i:       moduleId,
      /******/      l:       false,
      /******/      exports: {}
      /******/
    };
    /******/
    /******/ 		// Execute the module function
    /******/
    modules[ moduleId ].call(module.exports, module, module.exports, __webpack_require__);
    /******/
    /******/ 		// Flag the module as loaded
    /******/
    module.l = true;
    /******/
    /******/ 		// Return the exports of the module
    /******/
    return module.exports;
    /******/
  }

  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/
  __webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/
  __webpack_require__.c = installedModules;
  /******/
  /******/ 	// identity function for calling harmony imports with the correct context
  /******/
  __webpack_require__.i = function(value) {
    return value;
  };
  /******/
  /******/ 	// define getter function for harmony exports
  /******/
  __webpack_require__.d = function(exports, name, getter) {
    /******/
    if (!__webpack_require__.o(exports, name)) {
      /******/
      Object.defineProperty(exports, name, {
        /******/        configurable: false,
        /******/        enumerable:   true,
        /******/        get:          getter
        /******/
      });
      /******/
    }
    /******/
  };
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/
  __webpack_require__.n = function(module) {
    /******/
    var getter = module && module.__esModule ?
      /******/      function getDefault() {
        return module[ 'default' ];
      } :
      /******/      function getModuleExports() {
        return module;
      };
    /******/
    __webpack_require__.d(getter, 'a', getter);
    /******/
    return getter;
    /******/
  };
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/
  __webpack_require__.o = function(object, property) {
    return Object.prototype.hasOwnProperty.call(object, property);
  };
  /******/
  /******/ 	// __webpack_public_path__
  /******/
  __webpack_require__.p = "";
  /******/
  /******/ 	// Load entry module and return exports
  /******/
  return __webpack_require__(__webpack_require__.s = 37);
  /******/
})
/************************************************************************/
/******/([
  /* 0 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });

    var _GraphQLError = __webpack_require__(13);

    Object.defineProperty(exports, 'GraphQLError', {
      enumerable: true,
      get:        function get() {
        return _GraphQLError.GraphQLError;
      }
    });

    var _syntaxError = __webpack_require__(40);

    Object.defineProperty(exports, 'syntaxError', {
      enumerable: true,
      get:        function get() {
        return _syntaxError.syntaxError;
      }
    });

    var _locatedError = __webpack_require__(39);

    Object.defineProperty(exports, 'locatedError', {
      enumerable: true,
      get:        function get() {
        return _locatedError.locatedError;
      }
    });

    var _formatError = __webpack_require__(38);

    Object.defineProperty(exports, 'formatError', {
      enumerable: true,
      get:        function get() {
        return _formatError.formatError;
      }
    });

    /***/
  }),
  /* 1 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.GraphQLNonNull = exports.GraphQLList = exports.GraphQLInputObjectType = exports.GraphQLEnumType = exports.GraphQLUnionType = exports.GraphQLInterfaceType = exports.GraphQLObjectType = exports.GraphQLScalarType = undefined;

    var _extends = Object.assign || function(target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[ i ];
        for (var key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            target[ key ] = source[ key ];
          }
        }
      }
      return target;
    };

    exports.isType = isType;
    exports.assertType = assertType;
    exports.isInputType = isInputType;
    exports.assertInputType = assertInputType;
    exports.isOutputType = isOutputType;
    exports.assertOutputType = assertOutputType;
    exports.isLeafType = isLeafType;
    exports.assertLeafType = assertLeafType;
    exports.isCompositeType = isCompositeType;
    exports.assertCompositeType = assertCompositeType;
    exports.isAbstractType = isAbstractType;
    exports.assertAbstractType = assertAbstractType;
    exports.getNullableType = getNullableType;
    exports.isNamedType = isNamedType;
    exports.assertNamedType = assertNamedType;
    exports.getNamedType = getNamedType;

    var _invariant = __webpack_require__(3);

    var _invariant2 = _interopRequireDefault(_invariant);

    var _isNullish = __webpack_require__(6);

    var _isNullish2 = _interopRequireDefault(_isNullish);

    var _kinds = __webpack_require__(2);

    var _assertValidName = __webpack_require__(28);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

// Predicates & Assertions

    /**
     * These are all of the possible kinds of types.
     */
    function isType(type) {
      return type instanceof GraphQLScalarType || type instanceof GraphQLObjectType || type instanceof GraphQLInterfaceType || type instanceof GraphQLUnionType || type instanceof GraphQLEnumType || type instanceof GraphQLInputObjectType || type instanceof GraphQLList || type instanceof GraphQLNonNull;
    }

    function assertType(type) {
      (0, _invariant2.default)(isType(type), 'Expected ' + String(type) + ' to be a GraphQL type.');
      return type;
    }

    /**
     * These types may be used as input types for arguments and directives.
     */
    function isInputType(type) {
      var namedType = getNamedType(type);
      return namedType instanceof GraphQLScalarType || namedType instanceof GraphQLEnumType || namedType instanceof GraphQLInputObjectType;
    }

    function assertInputType(type) {
      (0, _invariant2.default)(isInputType(type), 'Expected ' + String(type) + ' to be a GraphQL input type.');
      return type;
    }

    /**
     * These types may be used as output types as the result of fields.
     */
    function isOutputType(type) {
      var namedType = getNamedType(type);
      return namedType instanceof GraphQLScalarType || namedType instanceof GraphQLObjectType || namedType instanceof GraphQLInterfaceType || namedType instanceof GraphQLUnionType || namedType instanceof GraphQLEnumType;
    }

    function assertOutputType(type) {
      (0, _invariant2.default)(isOutputType(type), 'Expected ' + String(type) + ' to be a GraphQL output type.');
      return type;
    }

    /**
     * These types may describe types which may be leaf values.
     */
    function isLeafType(type) {
      var namedType = getNamedType(type);
      return namedType instanceof GraphQLScalarType || namedType instanceof GraphQLEnumType;
    }

    function assertLeafType(type) {
      (0, _invariant2.default)(isLeafType(type), 'Expected ' + String(type) + ' to be a GraphQL leaf type.');
      return type;
    }

    /**
     * These types may describe the parent context of a selection set.
     */
    function isCompositeType(type) {
      return type instanceof GraphQLObjectType || type instanceof GraphQLInterfaceType || type instanceof GraphQLUnionType;
    }

    function assertCompositeType(type) {
      (0, _invariant2.default)(isCompositeType(type), 'Expected ' + String(type) + ' to be a GraphQL composite type.');
      return type;
    }

    /**
     * These types may describe the parent context of a selection set.
     */
    function isAbstractType(type) {
      return type instanceof GraphQLInterfaceType || type instanceof GraphQLUnionType;
    }

    function assertAbstractType(type) {
      (0, _invariant2.default)(isAbstractType(type), 'Expected ' + String(type) + ' to be a GraphQL abstract type.');
      return type;
    }

    /**
     * These types can all accept null as a value.
     */
    function getNullableType(type) {
      return type instanceof GraphQLNonNull ? type.ofType : type;
    }

    /**
     * These named types do not include modifiers like List or NonNull.
     */
    function isNamedType(type) {
      return type instanceof GraphQLScalarType || type instanceof GraphQLObjectType || type instanceof GraphQLInterfaceType || type instanceof GraphQLUnionType || type instanceof GraphQLEnumType || type instanceof GraphQLInputObjectType;
    }

    function assertNamedType(type) {
      (0, _invariant2.default)(isNamedType(type), 'Expected ' + String(type) + ' to be a GraphQL named type.');
      return type;
    }

    function getNamedType(type) {
      var unmodifiedType = type;
      while (unmodifiedType instanceof GraphQLList || unmodifiedType instanceof GraphQLNonNull) {
        unmodifiedType = unmodifiedType.ofType;
      }
      return unmodifiedType;
    }

    /**
     * Used while defining GraphQL types to allow for circular references in
     * otherwise immutable type definitions.
     */


    function resolveThunk(thunk) {
      return typeof thunk === 'function' ? thunk() : thunk;
    }

    /**
     * Scalar Type Definition
     *
     * The leaf values of any request and input values to arguments are
     * Scalars (or Enums) and are defined with a name and a series of functions
     * used to parse input from ast or variables and to ensure validity.
     *
     * Example:
     *
     *     const OddType = new GraphQLScalarType({
 *       name: 'Odd',
 *       serialize(value) {
 *         return value % 2 === 1 ? value : null;
 *       }
 *     });
     *
     */

    var GraphQLScalarType = exports.GraphQLScalarType = function() {
      function GraphQLScalarType(config) {
        _classCallCheck(this, GraphQLScalarType);

        (0, _assertValidName.assertValidName)(config.name);
        this.name = config.name;
        this.description = config.description;
        (0, _invariant2.default)(typeof config.serialize === 'function', this.name + ' must provide "serialize" function. If this custom Scalar ' + 'is also used as an input type, ensure "parseValue" and "parseLiteral" ' + 'functions are also provided.');
        if (config.parseValue || config.parseLiteral) {
          (0, _invariant2.default)(typeof config.parseValue === 'function' && typeof config.parseLiteral === 'function', this.name + ' must provide both "parseValue" and "parseLiteral" ' + 'functions.');
        }
        this._scalarConfig = config;
      }

      // Serializes an internal value to include in a response.

      GraphQLScalarType.prototype.serialize = function serialize(value) {
        var serializer = this._scalarConfig.serialize;
        return serializer(value);
      };

      // Parses an externally provided value to use as an input.

      GraphQLScalarType.prototype.parseValue = function parseValue(value) {
        var parser = this._scalarConfig.parseValue;
        return parser ? parser(value) : null;
      };

      // Parses an externally provided literal value to use as an input.

      GraphQLScalarType.prototype.parseLiteral = function parseLiteral(valueNode) {
        var parser = this._scalarConfig.parseLiteral;
        return parser ? parser(valueNode) : null;
      };

      GraphQLScalarType.prototype.toString = function toString() {
        return this.name;
      };

      return GraphQLScalarType;
    }();

// Also provide toJSON and inspect aliases for toString.

    GraphQLScalarType.prototype.toJSON = GraphQLScalarType.prototype.inspect = GraphQLScalarType.prototype.toString;

    /**
     * Object Type Definition
     *
     * Almost all of the GraphQL types you define will be object types. Object types
     * have a name, but most importantly describe their fields.
     *
     * Example:
     *
     *     const AddressType = new GraphQLObjectType({
 *       name: 'Address',
 *       fields: {
 *         street: { type: GraphQLString },
 *         number: { type: GraphQLInt },
 *         formatted: {
 *           type: GraphQLString,
 *           resolve(obj) {
 *             return obj.number + ' ' + obj.street
 *           }
 *         }
 *       }
 *     });
     *
     * When two types need to refer to each other, or a type needs to refer to
     * itself in a field, you can use a function expression (aka a closure or a
     * thunk) to supply the fields lazily.
     *
     * Example:
     *
     *     const PersonType = new GraphQLObjectType({
 *       name: 'Person',
 *       fields: () => ({
 *         name: { type: GraphQLString },
 *         bestFriend: { type: PersonType },
 *       })
 *     });
     *
     */
    var GraphQLObjectType = exports.GraphQLObjectType = function() {
      function GraphQLObjectType(config) {
        _classCallCheck(this, GraphQLObjectType);

        (0, _assertValidName.assertValidName)(config.name, config.isIntrospection);
        this.name = config.name;
        this.description = config.description;
        if (config.isTypeOf) {
          (0, _invariant2.default)(typeof config.isTypeOf === 'function', this.name + ' must provide "isTypeOf" as a function.');
        }
        this.isTypeOf = config.isTypeOf;
        this._typeConfig = config;
      }

      GraphQLObjectType.prototype.getFields = function getFields() {
        return this._fields || (this._fields = defineFieldMap(this, this._typeConfig.fields));
      };

      GraphQLObjectType.prototype.getInterfaces = function getInterfaces() {
        return this._interfaces || (this._interfaces = defineInterfaces(this, this._typeConfig.interfaces));
      };

      GraphQLObjectType.prototype.toString = function toString() {
        return this.name;
      };

      return GraphQLObjectType;
    }();

// Also provide toJSON and inspect aliases for toString.

    GraphQLObjectType.prototype.toJSON = GraphQLObjectType.prototype.inspect = GraphQLObjectType.prototype.toString;

    function defineInterfaces(type, interfacesThunk) {
      var interfaces = resolveThunk(interfacesThunk);
      if (!interfaces) {
        return [];
      }
      (0, _invariant2.default)(Array.isArray(interfaces), type.name + ' interfaces must be an Array or a function which returns ' + 'an Array.');
      interfaces.forEach(function(iface) {
        (0, _invariant2.default)(iface instanceof GraphQLInterfaceType, type.name + ' may only implement Interface types, it cannot ' + ('implement: ' + String(iface) + '.'));
        if (typeof iface.resolveType !== 'function') {
          (0, _invariant2.default)(typeof type.isTypeOf === 'function', 'Interface Type ' + iface.name + ' does not provide a "resolveType" ' + ('function and implementing Type ' + type.name + ' does not provide a ') + '"isTypeOf" function. There is no way to resolve this implementing ' + 'type during execution.');
        }
      });
      return interfaces;
    }

    function defineFieldMap(type, fieldsThunk) {
      var fieldMap = resolveThunk(fieldsThunk);
      (0, _invariant2.default)(isPlainObj(fieldMap), type.name + ' fields must be an object with field names as keys or a ' + 'function which returns such an object.');

      var fieldNames = Object.keys(fieldMap);
      (0, _invariant2.default)(fieldNames.length > 0, type.name + ' fields must be an object with field names as keys or a ' + 'function which returns such an object.');

      var resultFieldMap = {};
      fieldNames.forEach(function(fieldName) {
        (0, _assertValidName.assertValidName)(fieldName);
        var fieldConfig = fieldMap[ fieldName ];
        (0, _invariant2.default)(!fieldConfig.hasOwnProperty('isDeprecated'), type.name + '.' + fieldName + ' should provide "deprecationReason" instead ' + 'of "isDeprecated".');
        var field = _extends({}, fieldConfig, {
          isDeprecated: Boolean(fieldConfig.deprecationReason),
          name:         fieldName
        });
        (0, _invariant2.default)(isOutputType(field.type), type.name + '.' + fieldName + ' field type must be Output Type but ' + ('got: ' + String(field.type) + '.'));
        (0, _invariant2.default)(isValidResolver(field.resolve), type.name + '.' + fieldName + ' field resolver must be a function if ' + ('provided, but got: ' + String(field.resolve) + '.'));
        var argsConfig = fieldConfig.args;
        if (!argsConfig) {
          field.args = [];
        } else {
          (0, _invariant2.default)(isPlainObj(argsConfig), type.name + '.' + fieldName + ' args must be an object with argument ' + 'names as keys.');
          field.args = Object.keys(argsConfig).map(function(argName) {
            (0, _assertValidName.assertValidName)(argName);
            var arg = argsConfig[ argName ];
            (0, _invariant2.default)(isInputType(arg.type), type.name + '.' + fieldName + '(' + argName + ':) argument type must be ' + ('Input Type but got: ' + String(arg.type) + '.'));
            return {
              name:         argName,
              description:  arg.description === undefined ? null : arg.description,
              type:         arg.type,
              defaultValue: arg.defaultValue
            };
          });
        }
        resultFieldMap[ fieldName ] = field;
      });
      return resultFieldMap;
    }

    function isPlainObj(obj) {
      return obj && typeof obj === 'object' && !Array.isArray(obj);
    }

// If a resolver is defined, it must be a function.
    function isValidResolver(resolver) {
      return resolver == null || typeof resolver === 'function';
    }

    /**
     * Interface Type Definition
     *
     * When a field can return one of a heterogeneous set of types, a Interface type
     * is used to describe what types are possible, what fields are in common across
     * all types, as well as a function to determine which type is actually used
     * when the field is resolved.
     *
     * Example:
     *
     *     const EntityType = new GraphQLInterfaceType({
 *       name: 'Entity',
 *       fields: {
 *         name: { type: GraphQLString }
 *       }
 *     });
     *
     */
    var GraphQLInterfaceType = exports.GraphQLInterfaceType = function() {
      function GraphQLInterfaceType(config) {
        _classCallCheck(this, GraphQLInterfaceType);

        (0, _assertValidName.assertValidName)(config.name);
        this.name = config.name;
        this.description = config.description;
        if (config.resolveType) {
          (0, _invariant2.default)(typeof config.resolveType === 'function', this.name + ' must provide "resolveType" as a function.');
        }
        this.resolveType = config.resolveType;
        this._typeConfig = config;
      }

      GraphQLInterfaceType.prototype.getFields = function getFields() {
        return this._fields || (this._fields = defineFieldMap(this, this._typeConfig.fields));
      };

      GraphQLInterfaceType.prototype.toString = function toString() {
        return this.name;
      };

      return GraphQLInterfaceType;
    }();

// Also provide toJSON and inspect aliases for toString.

    GraphQLInterfaceType.prototype.toJSON = GraphQLInterfaceType.prototype.inspect = GraphQLInterfaceType.prototype.toString;

    /**
     * Union Type Definition
     *
     * When a field can return one of a heterogeneous set of types, a Union type
     * is used to describe what types are possible as well as providing a function
     * to determine which type is actually used when the field is resolved.
     *
     * Example:
     *
     *     const PetType = new GraphQLUnionType({
 *       name: 'Pet',
 *       types: [ DogType, CatType ],
 *       resolveType(value) {
 *         if (value instanceof Dog) {
 *           return DogType;
 *         }
 *         if (value instanceof Cat) {
 *           return CatType;
 *         }
 *       }
 *     });
     *
     */
    var GraphQLUnionType = exports.GraphQLUnionType = function() {
      function GraphQLUnionType(config) {
        _classCallCheck(this, GraphQLUnionType);

        (0, _assertValidName.assertValidName)(config.name);
        this.name = config.name;
        this.description = config.description;
        if (config.resolveType) {
          (0, _invariant2.default)(typeof config.resolveType === 'function', this.name + ' must provide "resolveType" as a function.');
        }
        this.resolveType = config.resolveType;
        this._typeConfig = config;
      }

      GraphQLUnionType.prototype.getTypes = function getTypes() {
        return this._types || (this._types = defineTypes(this, this._typeConfig.types));
      };

      GraphQLUnionType.prototype.toString = function toString() {
        return this.name;
      };

      return GraphQLUnionType;
    }();

// Also provide toJSON and inspect aliases for toString.

    GraphQLUnionType.prototype.toJSON = GraphQLUnionType.prototype.inspect = GraphQLUnionType.prototype.toString;

    function defineTypes(unionType, typesThunk) {
      var types = resolveThunk(typesThunk);

      (0, _invariant2.default)(Array.isArray(types) && types.length > 0, 'Must provide Array of types or a function which returns ' + ('such an array for Union ' + unionType.name + '.'));
      types.forEach(function(objType) {
        (0, _invariant2.default)(objType instanceof GraphQLObjectType, unionType.name + ' may only contain Object types, it cannot contain: ' + (String(objType) + '.'));
        if (typeof unionType.resolveType !== 'function') {
          (0, _invariant2.default)(typeof objType.isTypeOf === 'function', 'Union type "' + unionType.name + '" does not provide a "resolveType" ' + ('function and possible type "' + objType.name + '" does not provide an ') + '"isTypeOf" function. There is no way to resolve this possible type ' + 'during execution.');
        }
      });

      return types;
    }

    /**
     * Enum Type Definition
     *
     * Some leaf values of requests and input values are Enums. GraphQL serializes
     * Enum values as strings, however internally Enums can be represented by any
     * kind of type, often integers.
     *
     * Example:
     *
     *     const RGBType = new GraphQLEnumType({
 *       name: 'RGB',
 *       values: {
 *         RED: { value: 0 },
 *         GREEN: { value: 1 },
 *         BLUE: { value: 2 }
 *       }
 *     });
     *
     * Note: If a value is not provided in a definition, the name of the enum value
     * will be used as its internal value.
     */
    var GraphQLEnumType /* <T> */ = exports.GraphQLEnumType = function() {
      function GraphQLEnumType(config /* <T> */) {
        _classCallCheck(this, GraphQLEnumType);

        this.name = config.name;
        (0, _assertValidName.assertValidName)(config.name, config.isIntrospection);
        this.description = config.description;
        this._values = defineEnumValues(this, config.values);
        this._enumConfig = config;
      }

      GraphQLEnumType.prototype.getValues = function getValues() {
        return this._values;
      };

      GraphQLEnumType.prototype.getValue = function getValue(name) {
        return this._getNameLookup()[ name ];
      };

      GraphQLEnumType.prototype.serialize = function serialize(value /* T */) {
        var enumValue = this._getValueLookup().get(value);
        return enumValue ? enumValue.name : null;
      };

      GraphQLEnumType.prototype.parseValue = function parseValue(value) /* T */ {
        if (typeof value === 'string') {
          var enumValue = this._getNameLookup()[ value ];
          if (enumValue) {
            return enumValue.value;
          }
        }
      };

      GraphQLEnumType.prototype.parseLiteral = function parseLiteral(valueNode) /* T */ {
        if (valueNode.kind === _kinds.ENUM) {
          var enumValue = this._getNameLookup()[ valueNode.value ];
          if (enumValue) {
            return enumValue.value;
          }
        }
      };

      GraphQLEnumType.prototype._getValueLookup = function _getValueLookup() {
        var _this = this;

        if (!this._valueLookup) {
          (function() {
            var lookup = new Map();
            _this.getValues().forEach(function(value) {
              lookup.set(value.value, value);
            });
            _this._valueLookup = lookup;
          })();
        }
        return this._valueLookup;
      };

      GraphQLEnumType.prototype._getNameLookup = function _getNameLookup() {
        var _this2 = this;

        if (!this._nameLookup) {
          (function() {
            var lookup = Object.create(null);
            _this2.getValues().forEach(function(value) {
              lookup[ value.name ] = value;
            });
            _this2._nameLookup = lookup;
          })();
        }
        return this._nameLookup;
      };

      GraphQLEnumType.prototype.toString = function toString() {
        return this.name;
      };

      return GraphQLEnumType;
    }();

// Also provide toJSON and inspect aliases for toString.

    GraphQLEnumType.prototype.toJSON = GraphQLEnumType.prototype.inspect = GraphQLEnumType.prototype.toString;

    function defineEnumValues(type, valueMap /* <T> */
    ) {
      (0, _invariant2.default)(isPlainObj(valueMap), type.name + ' values must be an object with value names as keys.');
      var valueNames = Object.keys(valueMap);
      (0, _invariant2.default)(valueNames.length > 0, type.name + ' values must be an object with value names as keys.');
      return valueNames.map(function(valueName) {
        (0, _assertValidName.assertValidName)(valueName);
        var value = valueMap[ valueName ];
        (0, _invariant2.default)(isPlainObj(value), type.name + '.' + valueName + ' must refer to an object with a "value" key ' + ('representing an internal value but got: ' + String(value) + '.'));
        (0, _invariant2.default)(!value.hasOwnProperty('isDeprecated'), type.name + '.' + valueName + ' should provide "deprecationReason" instead ' + 'of "isDeprecated".');
        return {
          name:              valueName,
          description:       value.description,
          isDeprecated:      Boolean(value.deprecationReason),
          deprecationReason: value.deprecationReason,
          value:             (0, _isNullish2.default)(value.value) ? valueName : value.value
        };
      });
    }

    /* <T> */

    /**
     * Input Object Type Definition
     *
     * An input object defines a structured collection of fields which may be
     * supplied to a field argument.
     *
     * Using `NonNull` will ensure that a value must be provided by the query
     *
     * Example:
     *
     *     const GeoPoint = new GraphQLInputObjectType({
 *       name: 'GeoPoint',
 *       fields: {
 *         lat: { type: new GraphQLNonNull(GraphQLFloat) },
 *         lon: { type: new GraphQLNonNull(GraphQLFloat) },
 *         alt: { type: GraphQLFloat, defaultValue: 0 },
 *       }
 *     });
     *
     */
    var GraphQLInputObjectType = exports.GraphQLInputObjectType = function() {
      function GraphQLInputObjectType(config) {
        _classCallCheck(this, GraphQLInputObjectType);

        (0, _assertValidName.assertValidName)(config.name);
        this.name = config.name;
        this.description = config.description;
        this._typeConfig = config;
      }

      GraphQLInputObjectType.prototype.getFields = function getFields() {
        return this._fields || (this._fields = this._defineFieldMap());
      };

      GraphQLInputObjectType.prototype._defineFieldMap = function _defineFieldMap() {
        var _this3 = this;

        var fieldMap = resolveThunk(this._typeConfig.fields);
        (0, _invariant2.default)(isPlainObj(fieldMap), this.name + ' fields must be an object with field names as keys or a ' + 'function which returns such an object.');
        var fieldNames = Object.keys(fieldMap);
        (0, _invariant2.default)(fieldNames.length > 0, this.name + ' fields must be an object with field names as keys or a ' + 'function which returns such an object.');
        var resultFieldMap = {};
        fieldNames.forEach(function(fieldName) {
          (0, _assertValidName.assertValidName)(fieldName);
          var field = _extends({}, fieldMap[ fieldName ], {
            name: fieldName
          });
          (0, _invariant2.default)(isInputType(field.type), _this3.name + '.' + fieldName + ' field type must be Input Type but ' + ('got: ' + String(field.type) + '.'));
          (0, _invariant2.default)(field.resolve == null, _this3.name + '.' + fieldName + ' field type has a resolve property, but ' + 'Input Types cannot define resolvers.');
          resultFieldMap[ fieldName ] = field;
        });
        return resultFieldMap;
      };

      GraphQLInputObjectType.prototype.toString = function toString() {
        return this.name;
      };

      return GraphQLInputObjectType;
    }();

// Also provide toJSON and inspect aliases for toString.

    GraphQLInputObjectType.prototype.toJSON = GraphQLInputObjectType.prototype.inspect = GraphQLInputObjectType.prototype.toString;

    /**
     * List Modifier
     *
     * A list is a kind of type marker, a wrapping type which points to another
     * type. Lists are often created within the context of defining the fields of
     * an object type.
     *
     * Example:
     *
     *     const PersonType = new GraphQLObjectType({
 *       name: 'Person',
 *       fields: () => ({
 *         parents: { type: new GraphQLList(Person) },
 *         children: { type: new GraphQLList(Person) },
 *       })
 *     })
     *
     */
    var GraphQLList = exports.GraphQLList = function() {
      function GraphQLList(type) {
        _classCallCheck(this, GraphQLList);

        (0, _invariant2.default)(isType(type), 'Can only create List of a GraphQLType but got: ' + String(type) + '.');
        this.ofType = type;
      }

      GraphQLList.prototype.toString = function toString() {
        return '[' + String(this.ofType) + ']';
      };

      return GraphQLList;
    }();

// Also provide toJSON and inspect aliases for toString.

    GraphQLList.prototype.toJSON = GraphQLList.prototype.inspect = GraphQLList.prototype.toString;

    /**
     * Non-Null Modifier
     *
     * A non-null is a kind of type marker, a wrapping type which points to another
     * type. Non-null types enforce that their values are never null and can ensure
     * an error is raised if this ever occurs during a request. It is useful for
     * fields which you can make a strong guarantee on non-nullability, for example
     * usually the id field of a database row will never be null.
     *
     * Example:
     *
     *     const RowType = new GraphQLObjectType({
 *       name: 'Row',
 *       fields: () => ({
 *         id: { type: new GraphQLNonNull(GraphQLString) },
 *       })
 *     })
     *
     * Note: the enforcement of non-nullability occurs within the executor.
     */

    var GraphQLNonNull = exports.GraphQLNonNull = function() {
      function GraphQLNonNull(type) {
        _classCallCheck(this, GraphQLNonNull);

        (0, _invariant2.default)(isType(type) && !(type instanceof GraphQLNonNull), 'Can only create NonNull of a Nullable GraphQLType but got: ' + (String(type) + '.'));
        this.ofType = type;
      }

      GraphQLNonNull.prototype.toString = function toString() {
        return this.ofType.toString() + '!';
      };

      return GraphQLNonNull;
    }();

// Also provide toJSON and inspect aliases for toString.

    GraphQLNonNull.prototype.toJSON = GraphQLNonNull.prototype.inspect = GraphQLNonNull.prototype.toString;

    /***/
  }),
  /* 2 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

// Name

    var NAME = exports.NAME = 'Name';

// Document

    var DOCUMENT = exports.DOCUMENT = 'Document';
    var OPERATION_DEFINITION = exports.OPERATION_DEFINITION = 'OperationDefinition';
    var VARIABLE_DEFINITION = exports.VARIABLE_DEFINITION = 'VariableDefinition';
    var VARIABLE = exports.VARIABLE = 'Variable';
    var SELECTION_SET = exports.SELECTION_SET = 'SelectionSet';
    var FIELD = exports.FIELD = 'Field';
    var ARGUMENT = exports.ARGUMENT = 'Argument';

// Fragments

    var FRAGMENT_SPREAD = exports.FRAGMENT_SPREAD = 'FragmentSpread';
    var INLINE_FRAGMENT = exports.INLINE_FRAGMENT = 'InlineFragment';
    var FRAGMENT_DEFINITION = exports.FRAGMENT_DEFINITION = 'FragmentDefinition';

// Values

    var INT = exports.INT = 'IntValue';
    var FLOAT = exports.FLOAT = 'FloatValue';
    var STRING = exports.STRING = 'StringValue';
    var BOOLEAN = exports.BOOLEAN = 'BooleanValue';
    var NULL = exports.NULL = 'NullValue';
    var ENUM = exports.ENUM = 'EnumValue';
    var LIST = exports.LIST = 'ListValue';
    var OBJECT = exports.OBJECT = 'ObjectValue';
    var OBJECT_FIELD = exports.OBJECT_FIELD = 'ObjectField';

// Directives

    var DIRECTIVE = exports.DIRECTIVE = 'Directive';

// Types

    var NAMED_TYPE = exports.NAMED_TYPE = 'NamedType';
    var LIST_TYPE = exports.LIST_TYPE = 'ListType';
    var NON_NULL_TYPE = exports.NON_NULL_TYPE = 'NonNullType';

// Type System Definitions

    var SCHEMA_DEFINITION = exports.SCHEMA_DEFINITION = 'SchemaDefinition';
    var OPERATION_TYPE_DEFINITION = exports.OPERATION_TYPE_DEFINITION = 'OperationTypeDefinition';

// Type Definitions

    var SCALAR_TYPE_DEFINITION = exports.SCALAR_TYPE_DEFINITION = 'ScalarTypeDefinition';
    var OBJECT_TYPE_DEFINITION = exports.OBJECT_TYPE_DEFINITION = 'ObjectTypeDefinition';
    var FIELD_DEFINITION = exports.FIELD_DEFINITION = 'FieldDefinition';
    var INPUT_VALUE_DEFINITION = exports.INPUT_VALUE_DEFINITION = 'InputValueDefinition';
    var INTERFACE_TYPE_DEFINITION = exports.INTERFACE_TYPE_DEFINITION = 'InterfaceTypeDefinition';
    var UNION_TYPE_DEFINITION = exports.UNION_TYPE_DEFINITION = 'UnionTypeDefinition';
    var ENUM_TYPE_DEFINITION = exports.ENUM_TYPE_DEFINITION = 'EnumTypeDefinition';
    var ENUM_VALUE_DEFINITION = exports.ENUM_VALUE_DEFINITION = 'EnumValueDefinition';
    var INPUT_OBJECT_TYPE_DEFINITION = exports.INPUT_OBJECT_TYPE_DEFINITION = 'InputObjectTypeDefinition';

// Type Extensions

    var TYPE_EXTENSION_DEFINITION = exports.TYPE_EXTENSION_DEFINITION = 'TypeExtensionDefinition';

// Directive Definitions

    var DIRECTIVE_DEFINITION = exports.DIRECTIVE_DEFINITION = 'DirectiveDefinition';

    /***/
  }),
  /* 3 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = invariant;

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function invariant(condition, message) {
      if (!condition) {
        throw new Error(message);
      }
    }

    /***/
  }),
  /* 4 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.print = print;

    var _visitor = __webpack_require__(15);

    /**
     * Converts an AST into a string, using one set of reasonable
     * formatting rules.
     */
    function print(ast) {
      return (0, _visitor.visit)(ast, { leave: printDocASTReducer });
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    var printDocASTReducer = {
      Name:     function Name(node) {
        return node.value;
      },
      Variable: function Variable(node) {
        return '$' + node.name;
      },

      // Document

      Document: function Document(node) {
        return join(node.definitions, '\n\n') + '\n';
      },

      OperationDefinition: function OperationDefinition(node) {
        var op = node.operation;
        var name = node.name;
        var varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');
        var directives = join(node.directives, ' ');
        var selectionSet = node.selectionSet;
        // Anonymous queries with no directives or variable definitions can use
        // the query short form.
        return !name && !directives && !varDefs && op === 'query' ? selectionSet : join([ op, join([ name, varDefs ]), directives, selectionSet ], ' ');
      },

      VariableDefinition: function VariableDefinition(_ref) {
        var variable = _ref.variable,
          type = _ref.type,
          defaultValue = _ref.defaultValue;
        return variable + ': ' + type + wrap(' = ', defaultValue);
      },

      SelectionSet: function SelectionSet(_ref2) {
        var selections = _ref2.selections;
        return block(selections);
      },

      Field: function Field(_ref3) {
        var alias = _ref3.alias,
          name = _ref3.name,
          args = _ref3.arguments,
          directives = _ref3.directives,
          selectionSet = _ref3.selectionSet;
        return join([ wrap('', alias, ': ') + name + wrap('(', join(args, ', '), ')'), join(directives, ' '), selectionSet ], ' ');
      },

      Argument: function Argument(_ref4) {
        var name = _ref4.name,
          value = _ref4.value;
        return name + ': ' + value;
      },

      // Fragments

      FragmentSpread: function FragmentSpread(_ref5) {
        var name = _ref5.name,
          directives = _ref5.directives;
        return '...' + name + wrap(' ', join(directives, ' '));
      },

      InlineFragment: function InlineFragment(_ref6) {
        var typeCondition = _ref6.typeCondition,
          directives = _ref6.directives,
          selectionSet = _ref6.selectionSet;
        return join([ '...', wrap('on ', typeCondition), join(directives, ' '), selectionSet ], ' ');
      },

      FragmentDefinition: function FragmentDefinition(_ref7) {
        var name = _ref7.name,
          typeCondition = _ref7.typeCondition,
          directives = _ref7.directives,
          selectionSet = _ref7.selectionSet;
        return 'fragment ' + name + ' on ' + typeCondition + ' ' + wrap('', join(directives, ' '), ' ') + selectionSet;
      },

      // Value

      IntValue:     function IntValue(_ref8) {
        var value = _ref8.value;
        return value;
      },
      FloatValue:   function FloatValue(_ref9) {
        var value = _ref9.value;
        return value;
      },
      StringValue:  function StringValue(_ref10) {
        var value = _ref10.value;
        return JSON.stringify(value);
      },
      BooleanValue: function BooleanValue(_ref11) {
        var value = _ref11.value;
        return JSON.stringify(value);
      },
      NullValue:    function NullValue() {
        return 'null';
      },
      EnumValue:    function EnumValue(_ref12) {
        var value = _ref12.value;
        return value;
      },
      ListValue:    function ListValue(_ref13) {
        var values = _ref13.values;
        return '[' + join(values, ', ') + ']';
      },
      ObjectValue:  function ObjectValue(_ref14) {
        var fields = _ref14.fields;
        return '{' + join(fields, ', ') + '}';
      },
      ObjectField:  function ObjectField(_ref15) {
        var name = _ref15.name,
          value = _ref15.value;
        return name + ': ' + value;
      },

      // Directive

      Directive: function Directive(_ref16) {
        var name = _ref16.name,
          args = _ref16.arguments;
        return '@' + name + wrap('(', join(args, ', '), ')');
      },

      // Type

      NamedType:   function NamedType(_ref17) {
        var name = _ref17.name;
        return name;
      },
      ListType:    function ListType(_ref18) {
        var type = _ref18.type;
        return '[' + type + ']';
      },
      NonNullType: function NonNullType(_ref19) {
        var type = _ref19.type;
        return type + '!';
      },

      // Type System Definitions

      SchemaDefinition: function SchemaDefinition(_ref20) {
        var directives = _ref20.directives,
          operationTypes = _ref20.operationTypes;
        return join([ 'schema', join(directives, ' '), block(operationTypes) ], ' ');
      },

      OperationTypeDefinition: function OperationTypeDefinition(_ref21) {
        var operation = _ref21.operation,
          type = _ref21.type;
        return operation + ': ' + type;
      },

      ScalarTypeDefinition: function ScalarTypeDefinition(_ref22) {
        var name = _ref22.name,
          directives = _ref22.directives;
        return join([ 'scalar', name, join(directives, ' ') ], ' ');
      },

      ObjectTypeDefinition: function ObjectTypeDefinition(_ref23) {
        var name = _ref23.name,
          interfaces = _ref23.interfaces,
          directives = _ref23.directives,
          fields = _ref23.fields;
        return join([ 'type', name, wrap('implements ', join(interfaces, ', ')), join(directives, ' '), block(fields) ], ' ');
      },

      FieldDefinition: function FieldDefinition(_ref24) {
        var name = _ref24.name,
          args = _ref24.arguments,
          type = _ref24.type,
          directives = _ref24.directives;
        return name + wrap('(', join(args, ', '), ')') + ': ' + type + wrap(' ', join(directives, ' '));
      },

      InputValueDefinition: function InputValueDefinition(_ref25) {
        var name = _ref25.name,
          type = _ref25.type,
          defaultValue = _ref25.defaultValue,
          directives = _ref25.directives;
        return join([ name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ') ], ' ');
      },

      InterfaceTypeDefinition: function InterfaceTypeDefinition(_ref26) {
        var name = _ref26.name,
          directives = _ref26.directives,
          fields = _ref26.fields;
        return join([ 'interface', name, join(directives, ' '), block(fields) ], ' ');
      },

      UnionTypeDefinition: function UnionTypeDefinition(_ref27) {
        var name = _ref27.name,
          directives = _ref27.directives,
          types = _ref27.types;
        return join([ 'union', name, join(directives, ' '), '= ' + join(types, ' | ') ], ' ');
      },

      EnumTypeDefinition: function EnumTypeDefinition(_ref28) {
        var name = _ref28.name,
          directives = _ref28.directives,
          values = _ref28.values;
        return join([ 'enum', name, join(directives, ' '), block(values) ], ' ');
      },

      EnumValueDefinition: function EnumValueDefinition(_ref29) {
        var name = _ref29.name,
          directives = _ref29.directives;
        return join([ name, join(directives, ' ') ], ' ');
      },

      InputObjectTypeDefinition: function InputObjectTypeDefinition(_ref30) {
        var name = _ref30.name,
          directives = _ref30.directives,
          fields = _ref30.fields;
        return join([ 'input', name, join(directives, ' '), block(fields) ], ' ');
      },

      TypeExtensionDefinition: function TypeExtensionDefinition(_ref31) {
        var definition = _ref31.definition;
        return 'extend ' + definition;
      },

      DirectiveDefinition: function DirectiveDefinition(_ref32) {
        var name = _ref32.name,
          args = _ref32.arguments,
          locations = _ref32.locations;
        return 'directive @' + name + wrap('(', join(args, ', '), ')') + ' on ' + join(locations, ' | ');
      }
    };

    /**
     * Given maybeArray, print an empty string if it is null or empty, otherwise
     * print all items together separated by separator if provided
     */
    function join(maybeArray, separator) {
      return maybeArray ? maybeArray.filter(function(x) {
        return x;
      }).join(separator || '') : '';
    }

    /**
     * Given array, print each item on its own line, wrapped in an
     * indented "{ }" block.
     */
    function block(array) {
      return array && array.length !== 0 ? indent('{\n' + join(array, '\n')) + '\n}' : '{}';
    }

    /**
     * If maybeString is not null or empty, then wrap with start and end, otherwise
     * print an empty string.
     */
    function wrap(start, maybeString, end) {
      return maybeString ? start + maybeString + (end || '') : '';
    }

    function indent(maybeString) {
      return maybeString && maybeString.replace(/\n/g, '\n  ');
    }

    /***/
  }),
  /* 5 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.specifiedDirectives = exports.GraphQLDeprecatedDirective = exports.DEFAULT_DEPRECATION_REASON = exports.GraphQLSkipDirective = exports.GraphQLIncludeDirective = exports.GraphQLDirective = exports.DirectiveLocation = undefined;

    var _definition = __webpack_require__(1);

    var _scalars = __webpack_require__(7);

    var _invariant = __webpack_require__(3);

    var _invariant2 = _interopRequireDefault(_invariant);

    var _assertValidName = __webpack_require__(28);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    var DirectiveLocation = exports.DirectiveLocation = {
      // Operations
      QUERY:                  'QUERY',
      MUTATION:               'MUTATION',
      SUBSCRIPTION:           'SUBSCRIPTION',
      FIELD:                  'FIELD',
      FRAGMENT_DEFINITION:    'FRAGMENT_DEFINITION',
      FRAGMENT_SPREAD:        'FRAGMENT_SPREAD',
      INLINE_FRAGMENT:        'INLINE_FRAGMENT',
      // Schema Definitions
      SCHEMA:                 'SCHEMA',
      SCALAR:                 'SCALAR',
      OBJECT:                 'OBJECT',
      FIELD_DEFINITION:       'FIELD_DEFINITION',
      ARGUMENT_DEFINITION:    'ARGUMENT_DEFINITION',
      INTERFACE:              'INTERFACE',
      UNION:                  'UNION',
      ENUM:                   'ENUM',
      ENUM_VALUE:             'ENUM_VALUE',
      INPUT_OBJECT:           'INPUT_OBJECT',
      INPUT_FIELD_DEFINITION: 'INPUT_FIELD_DEFINITION'
    };

// eslint-disable-line

    /**
     * Directives are used by the GraphQL runtime as a way of modifying execution
     * behavior. Type system creators will usually not create these directly.
     */
    var GraphQLDirective = exports.GraphQLDirective = function GraphQLDirective(config) {
      _classCallCheck(this, GraphQLDirective);

      (0, _invariant2.default)(config.name, 'Directive must be named.');
      (0, _assertValidName.assertValidName)(config.name);
      (0, _invariant2.default)(Array.isArray(config.locations), 'Must provide locations for directive.');
      this.name = config.name;
      this.description = config.description;
      this.locations = config.locations;

      var args = config.args;
      if (!args) {
        this.args = [];
      } else {
        (0, _invariant2.default)(!Array.isArray(args), '@' + config.name + ' args must be an object with argument names as keys.');
        this.args = Object.keys(args).map(function(argName) {
          (0, _assertValidName.assertValidName)(argName);
          var arg = args[ argName ];
          (0, _invariant2.default)((0, _definition.isInputType)(arg.type), '@' + config.name + '(' + argName + ':) argument type must be ' + ('Input Type but got: ' + String(arg.type) + '.'));
          return {
            name:         argName,
            description:  arg.description === undefined ? null : arg.description,
            type:         arg.type,
            defaultValue: arg.defaultValue
          };
        });
      }
    };

    /**
     * Used to conditionally include fields or fragments.
     */
    var GraphQLIncludeDirective = exports.GraphQLIncludeDirective = new GraphQLDirective({
      name:        'include',
      description: 'Directs the executor to include this field or fragment only when ' + 'the `if` argument is true.',
      locations:   [ DirectiveLocation.FIELD, DirectiveLocation.FRAGMENT_SPREAD, DirectiveLocation.INLINE_FRAGMENT ],
      args:        {
        'if': {
          type:        new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
          description: 'Included when true.'
        }
      }
    });

    /**
     * Used to conditionally skip (exclude) fields or fragments.
     */
    var GraphQLSkipDirective = exports.GraphQLSkipDirective = new GraphQLDirective({
      name:        'skip',
      description: 'Directs the executor to skip this field or fragment when the `if` ' + 'argument is true.',
      locations:   [ DirectiveLocation.FIELD, DirectiveLocation.FRAGMENT_SPREAD, DirectiveLocation.INLINE_FRAGMENT ],
      args:        {
        'if': {
          type:        new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
          description: 'Skipped when true.'
        }
      }
    });

    /**
     * Constant string used for default reason for a deprecation.
     */
    var DEFAULT_DEPRECATION_REASON = exports.DEFAULT_DEPRECATION_REASON = 'No longer supported';

    /**
     * Used to declare element of a GraphQL schema as deprecated.
     */
    var GraphQLDeprecatedDirective = exports.GraphQLDeprecatedDirective = new GraphQLDirective({
      name:        'deprecated',
      description: 'Marks an element of a GraphQL schema as no longer supported.',
      locations:   [ DirectiveLocation.FIELD_DEFINITION, DirectiveLocation.ENUM_VALUE ],
      args:        {
        reason: {
          type:         _scalars.GraphQLString,
          description:  'Explains why this element was deprecated, usually also including a ' + 'suggestion for how to access supported similar data. Formatted ' + 'in [Markdown](https://daringfireball.net/projects/markdown/).',
          defaultValue: DEFAULT_DEPRECATION_REASON
        }
      }
    });

    /**
     * The full list of specified directives.
     */
    var specifiedDirectives = exports.specifiedDirectives = [ GraphQLIncludeDirective, GraphQLSkipDirective, GraphQLDeprecatedDirective ];

    /***/
  }),
  /* 6 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isNullish;

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    /**
     * Returns true if a value is null, undefined, or NaN.
     */
    function isNullish(value) {
      return value === null || value === undefined || value !== value;
    }

    /***/
  }),
  /* 7 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.GraphQLID = exports.GraphQLBoolean = exports.GraphQLString = exports.GraphQLFloat = exports.GraphQLInt = undefined;

    var _definition = __webpack_require__(1);

    var _kinds = __webpack_require__(2);

    var Kind = _interopRequireWildcard(_kinds);

    function _interopRequireWildcard(obj) {
      if (obj && obj.__esModule) {
        return obj;
      } else {
        var newObj = {};
        if (obj != null) {
          for (var key in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[ key ] = obj[ key ];
          }
        }
        newObj.default = obj;
        return newObj;
      }
    }

// As per the GraphQL Spec, Integers are only treated as valid when a valid
// 32-bit signed integer, providing the broadest support across platforms.
//
// n.b. JavaScript's integers are safe between -(2^53 - 1) and 2^53 - 1 because
// they are internally represented as IEEE 754 doubles.

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    var MAX_INT = 2147483647;
    var MIN_INT = -2147483648;

    function coerceInt(value) {
      if (value === '') {
        throw new TypeError('Int cannot represent non 32-bit signed integer value: (empty string)');
      }
      var num = Number(value);
      if (num === num && num <= MAX_INT && num >= MIN_INT) {
        return (num < 0 ? Math.ceil : Math.floor)(num);
      }
      throw new TypeError('Int cannot represent non 32-bit signed integer value: ' + String(value));
    }

    var GraphQLInt = exports.GraphQLInt = new _definition.GraphQLScalarType({
      name:         'Int',
      description:  'The `Int` scalar type represents non-fractional signed whole numeric ' + 'values. Int can represent values between -(2^31) and 2^31 - 1. ',
      serialize:    coerceInt,
      parseValue:   coerceInt,
      parseLiteral: function parseLiteral(ast) {
        if (ast.kind === Kind.INT) {
          var num = parseInt(ast.value, 10);
          if (num <= MAX_INT && num >= MIN_INT) {
            return num;
          }
        }
        return null;
      }
    });

    function coerceFloat(value) {
      if (value === '') {
        throw new TypeError('Float cannot represent non numeric value: (empty string)');
      }
      var num = Number(value);
      if (num === num) {
        return num;
      }
      throw new TypeError('Float cannot represent non numeric value: ' + String(value));
    }

    var GraphQLFloat = exports.GraphQLFloat = new _definition.GraphQLScalarType({
      name:         'Float',
      description:  'The `Float` scalar type represents signed double-precision fractional ' + 'values as specified by ' + '[IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point). ',
      serialize:    coerceFloat,
      parseValue:   coerceFloat,
      parseLiteral: function parseLiteral(ast) {
        return ast.kind === Kind.FLOAT || ast.kind === Kind.INT ? parseFloat(ast.value) : null;
      }
    });

    var GraphQLString = exports.GraphQLString = new _definition.GraphQLScalarType({
      name:         'String',
      description:  'The `String` scalar type represents textual data, represented as UTF-8 ' + 'character sequences. The String type is most often used by GraphQL to ' + 'represent free-form human-readable text.',
      serialize:    String,
      parseValue:   String,
      parseLiteral: function parseLiteral(ast) {
        return ast.kind === Kind.STRING ? ast.value : null;
      }
    });

    var GraphQLBoolean = exports.GraphQLBoolean = new _definition.GraphQLScalarType({
      name:         'Boolean',
      description:  'The `Boolean` scalar type represents `true` or `false`.',
      serialize:    Boolean,
      parseValue:   Boolean,
      parseLiteral: function parseLiteral(ast) {
        return ast.kind === Kind.BOOLEAN ? ast.value : null;
      }
    });

    var GraphQLID = exports.GraphQLID = new _definition.GraphQLScalarType({
      name:         'ID',
      description:  'The `ID` scalar type represents a unique identifier, often used to ' + 'refetch an object or as key for a cache. The ID type appears in a JSON ' + 'response as a String; however, it is not intended to be human-readable. ' + 'When expected as an input type, any string (such as `"4"`) or integer ' + '(such as `4`) input value will be accepted as an ID.',
      serialize:    String,
      parseValue:   String,
      parseLiteral: function parseLiteral(ast) {
        return ast.kind === Kind.STRING || ast.kind === Kind.INT ? ast.value : null;
      }
    });

    /***/
  }),
  /* 8 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.GraphQLSchema = undefined;

    var _definition = __webpack_require__(1);

    var _directives = __webpack_require__(5);

    var _introspection = __webpack_require__(11);

    var _find = __webpack_require__(10);

    var _find2 = _interopRequireDefault(_find);

    var _invariant = __webpack_require__(3);

    var _invariant2 = _interopRequireDefault(_invariant);

    var _typeComparators = __webpack_require__(19);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    /**
     * Schema Definition
     *
     * A Schema is created by supplying the root types of each type of operation,
     * query and mutation (optional). A schema definition is then supplied to the
     * validator and executor.
     *
     * Example:
     *
     *     const MyAppSchema = new GraphQLSchema({
 *       query: MyAppQueryRootType,
 *       mutation: MyAppMutationRootType,
 *     })
     *
     * Note: If an array of `directives` are provided to GraphQLSchema, that will be
     * the exact list of directives represented and allowed. If `directives` is not
     * provided then a default set of the specified directives (e.g. @include and
     * @skip) will be used. If you wish to provide *additional* directives to these
     * specified directives, you must explicitly declare them. Example:
     *
     *     const MyAppSchema = new GraphQLSchema({
 *       ...
 *       directives: specifiedDirectives.concat([ myCustomDirective ]),
 *     })
     *
     */
    var GraphQLSchema = exports.GraphQLSchema = function() {
      function GraphQLSchema(config) {
        var _this = this;

        _classCallCheck(this, GraphQLSchema);

        (0, _invariant2.default)(typeof config === 'object', 'Must provide configuration object.');

        (0, _invariant2.default)(config.query instanceof _definition.GraphQLObjectType, 'Schema query must be Object Type but got: ' + String(config.query) + '.');
        this._queryType = config.query;

        (0, _invariant2.default)(!config.mutation || config.mutation instanceof _definition.GraphQLObjectType, 'Schema mutation must be Object Type if provided but got: ' + String(config.mutation) + '.');
        this._mutationType = config.mutation;

        (0, _invariant2.default)(!config.subscription || config.subscription instanceof _definition.GraphQLObjectType, 'Schema subscription must be Object Type if provided but got: ' + String(config.subscription) + '.');
        this._subscriptionType = config.subscription;

        (0, _invariant2.default)(!config.types || Array.isArray(config.types), 'Schema types must be Array if provided but got: ' + String(config.types) + '.');

        (0, _invariant2.default)(!config.directives || Array.isArray(config.directives) && config.directives.every(function(directive) {
          return directive instanceof _directives.GraphQLDirective;
        }), 'Schema directives must be Array<GraphQLDirective> if provided but got: ' + String(config.directives) + '.');
        // Provide specified directives (e.g. @include and @skip) by default.
        this._directives = config.directives || _directives.specifiedDirectives;

        // Build type map now to detect any errors within this schema.
        var initialTypes = [ this.getQueryType(), this.getMutationType(), this.getSubscriptionType(), _introspection.__Schema ];

        var types = config.types;
        if (types) {
          initialTypes = initialTypes.concat(types);
        }

        this._typeMap = initialTypes.reduce(typeMapReducer, Object.create(null));

        // Keep track of all implementations by interface name.
        this._implementations = Object.create(null);
        Object.keys(this._typeMap).forEach(function(typeName) {
          var type = _this._typeMap[ typeName ];
          if (type instanceof _definition.GraphQLObjectType) {
            type.getInterfaces().forEach(function(iface) {
              var impls = _this._implementations[ iface.name ];
              if (impls) {
                impls.push(type);
              } else {
                _this._implementations[ iface.name ] = [ type ];
              }
            });
          }
        });

        // Enforce correct interface implementations.
        Object.keys(this._typeMap).forEach(function(typeName) {
          var type = _this._typeMap[ typeName ];
          if (type instanceof _definition.GraphQLObjectType) {
            type.getInterfaces().forEach(function(iface) {
              return assertObjectImplementsInterface(_this, type, iface);
            });
          }
        });
      }

      GraphQLSchema.prototype.getQueryType = function getQueryType() {
        return this._queryType;
      };

      GraphQLSchema.prototype.getMutationType = function getMutationType() {
        return this._mutationType;
      };

      GraphQLSchema.prototype.getSubscriptionType = function getSubscriptionType() {
        return this._subscriptionType;
      };

      GraphQLSchema.prototype.getTypeMap = function getTypeMap() {
        return this._typeMap;
      };

      GraphQLSchema.prototype.getType = function getType(name) {
        return this.getTypeMap()[ name ];
      };

      GraphQLSchema.prototype.getPossibleTypes = function getPossibleTypes(abstractType) {
        if (abstractType instanceof _definition.GraphQLUnionType) {
          return abstractType.getTypes();
        }
        (0, _invariant2.default)(abstractType instanceof _definition.GraphQLInterfaceType);
        return this._implementations[ abstractType.name ];
      };

      GraphQLSchema.prototype.isPossibleType = function isPossibleType(abstractType, possibleType) {
        var possibleTypeMap = this._possibleTypeMap;
        if (!possibleTypeMap) {
          this._possibleTypeMap = possibleTypeMap = Object.create(null);
        }

        if (!possibleTypeMap[ abstractType.name ]) {
          var possibleTypes = this.getPossibleTypes(abstractType);
          (0, _invariant2.default)(Array.isArray(possibleTypes), 'Could not find possible implementing types for ' + abstractType.name + ' ' + 'in schema. Check that schema.types is defined and is an array of ' + 'all possible types in the schema.');
          possibleTypeMap[ abstractType.name ] = possibleTypes.reduce(function(map, type) {
            return map[ type.name ] = true, map;
          }, Object.create(null));
        }

        return Boolean(possibleTypeMap[ abstractType.name ][ possibleType.name ]);
      };

      GraphQLSchema.prototype.getDirectives = function getDirectives() {
        return this._directives;
      };

      GraphQLSchema.prototype.getDirective = function getDirective(name) {
        return (0, _find2.default)(this.getDirectives(), function(directive) {
          return directive.name === name;
        });
      };

      return GraphQLSchema;
    }();

    function typeMapReducer(map, type) {
      if (!type) {
        return map;
      }
      if (type instanceof _definition.GraphQLList || type instanceof _definition.GraphQLNonNull) {
        return typeMapReducer(map, type.ofType);
      }
      if (map[ type.name ]) {
        (0, _invariant2.default)(map[ type.name ] === type, 'Schema must contain unique named types but contains multiple ' + ('types named "' + type.name + '".'));
        return map;
      }
      map[ type.name ] = type;

      var reducedMap = map;

      if (type instanceof _definition.GraphQLUnionType) {
        reducedMap = type.getTypes().reduce(typeMapReducer, reducedMap);
      }

      if (type instanceof _definition.GraphQLObjectType) {
        reducedMap = type.getInterfaces().reduce(typeMapReducer, reducedMap);
      }

      if (type instanceof _definition.GraphQLObjectType || type instanceof _definition.GraphQLInterfaceType) {
        (function() {
          var fieldMap = type.getFields();
          Object.keys(fieldMap).forEach(function(fieldName) {
            var field = fieldMap[ fieldName ];

            if (field.args) {
              var fieldArgTypes = field.args.map(function(arg) {
                return arg.type;
              });
              reducedMap = fieldArgTypes.reduce(typeMapReducer, reducedMap);
            }
            reducedMap = typeMapReducer(reducedMap, field.type);
          });
        })();
      }

      if (type instanceof _definition.GraphQLInputObjectType) {
        (function() {
          var fieldMap = type.getFields();
          Object.keys(fieldMap).forEach(function(fieldName) {
            var field = fieldMap[ fieldName ];
            reducedMap = typeMapReducer(reducedMap, field.type);
          });
        })();
      }

      return reducedMap;
    }

    function assertObjectImplementsInterface(schema, object, iface) {
      var objectFieldMap = object.getFields();
      var ifaceFieldMap = iface.getFields();

      // Assert each interface field is implemented.
      Object.keys(ifaceFieldMap).forEach(function(fieldName) {
        var objectField = objectFieldMap[ fieldName ];
        var ifaceField = ifaceFieldMap[ fieldName ];

        // Assert interface field exists on object.
        (0, _invariant2.default)(objectField, '"' + iface.name + '" expects field "' + fieldName + '" but "' + object.name + '" ' + 'does not provide it.');

        // Assert interface field type is satisfied by object field type, by being
        // a valid subtype. (covariant)
        (0, _invariant2.default)((0, _typeComparators.isTypeSubTypeOf)(schema, objectField.type, ifaceField.type), iface.name + '.' + fieldName + ' expects type "' + String(ifaceField.type) + '" ' + 'but ' + (object.name + '.' + fieldName + ' provides type "' + String(objectField.type) + '".'));

        // Assert each interface field arg is implemented.
        ifaceField.args.forEach(function(ifaceArg) {
          var argName = ifaceArg.name;
          var objectArg = (0, _find2.default)(objectField.args, function(arg) {
            return arg.name === argName;
          });

          // Assert interface field arg exists on object field.
          (0, _invariant2.default)(objectArg, iface.name + '.' + fieldName + ' expects argument "' + argName + '" but ' + (object.name + '.' + fieldName + ' does not provide it.'));

          // Assert interface field arg type matches object field arg type.
          // (invariant)
          (0, _invariant2.default)((0, _typeComparators.isEqualType)(ifaceArg.type, objectArg.type), iface.name + '.' + fieldName + '(' + argName + ':) expects type ' + ('"' + String(ifaceArg.type) + '" but ') + (object.name + '.' + fieldName + '(' + argName + ':) provides type ') + ('"' + String(objectArg.type) + '".'));
        });

        // Assert additional arguments must not be required.
        objectField.args.forEach(function(objectArg) {
          var argName = objectArg.name;
          var ifaceArg = (0, _find2.default)(ifaceField.args, function(arg) {
            return arg.name === argName;
          });
          if (!ifaceArg) {
            (0, _invariant2.default)(!(objectArg.type instanceof _definition.GraphQLNonNull), object.name + '.' + fieldName + '(' + argName + ':) is of required type ' + ('"' + String(objectArg.type) + '" but is not also provided by the ') + ('interface ' + iface.name + '.' + fieldName + '.'));
          }
        });
      });
    }

    /***/
  }),
  /* 9 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.typeFromAST = typeFromAST;

    var _invariant = __webpack_require__(3);

    var _invariant2 = _interopRequireDefault(_invariant);

    var _kinds = __webpack_require__(2);

    var _definition = __webpack_require__(1);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    function typeFromAST(schema, typeNode) {
      var innerType = void 0;
      if (typeNode.kind === _kinds.LIST_TYPE) {
        innerType = typeFromAST(schema, typeNode.type);
        return innerType && new _definition.GraphQLList(innerType);
      }
      if (typeNode.kind === _kinds.NON_NULL_TYPE) {
        innerType = typeFromAST(schema, typeNode.type);
        return innerType && new _definition.GraphQLNonNull(innerType);
      }
      (0, _invariant2.default)(typeNode.kind === _kinds.NAMED_TYPE, 'Must be a named type.');
      return schema.getType(typeNode.name.value);
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    /***/
  }),
  /* 10 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = find;

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function find(list, predicate) {
      for (var i = 0; i < list.length; i++) {
        if (predicate(list[ i ])) {
          return list[ i ];
        }
      }
    }

    /***/
  }),
  /* 11 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.TypeNameMetaFieldDef = exports.TypeMetaFieldDef = exports.SchemaMetaFieldDef = exports.__TypeKind = exports.TypeKind = exports.__EnumValue = exports.__InputValue = exports.__Field = exports.__Type = exports.__DirectiveLocation = exports.__Directive = exports.__Schema = undefined;

    var _isInvalid = __webpack_require__(14);

    var _isInvalid2 = _interopRequireDefault(_isInvalid);

    var _astFromValue = __webpack_require__(29);

    var _printer = __webpack_require__(4);

    var _definition = __webpack_require__(1);

    var _scalars = __webpack_require__(7);

    var _directives = __webpack_require__(5);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    var __Schema = exports.__Schema = new _definition.GraphQLObjectType({
      name:            '__Schema',
      isIntrospection: true,
      description:     'A GraphQL Schema defines the capabilities of a GraphQL server. It ' + 'exposes all available types and directives on the server, as well as ' + 'the entry points for query, mutation, and subscription operations.',
      fields:          function fields() {
        return {
          types:            {
            description: 'A list of all types supported by this server.',
            type:        new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__Type))),
            resolve:     function resolve(schema) {
              var typeMap = schema.getTypeMap();
              return Object.keys(typeMap).map(function(key) {
                return typeMap[ key ];
              });
            }
          },
          queryType:        {
            description: 'The type that query operations will be rooted at.',
            type:        new _definition.GraphQLNonNull(__Type),
            resolve:     function resolve(schema) {
              return schema.getQueryType();
            }
          },
          mutationType:     {
            description: 'If this server supports mutation, the type that ' + 'mutation operations will be rooted at.',
            type:        __Type,
            resolve:     function resolve(schema) {
              return schema.getMutationType();
            }
          },
          subscriptionType: {
            description: 'If this server support subscription, the type that ' + 'subscription operations will be rooted at.',
            type:        __Type,
            resolve:     function resolve(schema) {
              return schema.getSubscriptionType();
            }
          },
          directives:       {
            description: 'A list of all directives supported by this server.',
            type:        new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__Directive))),
            resolve:     function resolve(schema) {
              return schema.getDirectives();
            }
          }
        };
      }
    });

    var __Directive = exports.__Directive = new _definition.GraphQLObjectType({
      name:            '__Directive',
      isIntrospection: true,
      description:     'A Directive provides a way to describe alternate runtime execution and ' + 'type validation behavior in a GraphQL document.' + '\n\nIn some cases, you need to provide options to alter GraphQL\'s ' + 'execution behavior in ways field arguments will not suffice, such as ' + 'conditionally including or skipping a field. Directives provide this by ' + 'describing additional information to the executor.',
      fields:          function fields() {
        return {
          name:        { type: new _definition.GraphQLNonNull(_scalars.GraphQLString) },
          description: { type: _scalars.GraphQLString },
          locations:   {
            type: new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__DirectiveLocation)))
          },
          args:        {
            type:    new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__InputValue))),
            resolve: function resolve(directive) {
              return directive.args || [];
            }
          },
          // NOTE: the following three fields are deprecated and are no longer part
          // of the GraphQL specification.
          onOperation: {
            deprecationReason: 'Use `locations`.',
            type:              new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
            resolve:           function resolve(d) {
              return d.locations.indexOf(_directives.DirectiveLocation.QUERY) !== -1 || d.locations.indexOf(_directives.DirectiveLocation.MUTATION) !== -1 || d.locations.indexOf(_directives.DirectiveLocation.SUBSCRIPTION) !== -1;
            }
          },
          onFragment:  {
            deprecationReason: 'Use `locations`.',
            type:              new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
            resolve:           function resolve(d) {
              return d.locations.indexOf(_directives.DirectiveLocation.FRAGMENT_SPREAD) !== -1 || d.locations.indexOf(_directives.DirectiveLocation.INLINE_FRAGMENT) !== -1 || d.locations.indexOf(_directives.DirectiveLocation.FRAGMENT_DEFINITION) !== -1;
            }
          },
          onField:     {
            deprecationReason: 'Use `locations`.',
            type:              new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
            resolve:           function resolve(d) {
              return d.locations.indexOf(_directives.DirectiveLocation.FIELD) !== -1;
            }
          }
        };
      }
    });

    var __DirectiveLocation = exports.__DirectiveLocation = new _definition.GraphQLEnumType({
      name:            '__DirectiveLocation',
      isIntrospection: true,
      description:     'A Directive can be adjacent to many parts of the GraphQL language, a ' + '__DirectiveLocation describes one such possible adjacencies.',
      values:          {
        QUERY:                  {
          value:       _directives.DirectiveLocation.QUERY,
          description: 'Location adjacent to a query operation.'
        },
        MUTATION:               {
          value:       _directives.DirectiveLocation.MUTATION,
          description: 'Location adjacent to a mutation operation.'
        },
        SUBSCRIPTION:           {
          value:       _directives.DirectiveLocation.SUBSCRIPTION,
          description: 'Location adjacent to a subscription operation.'
        },
        FIELD:                  {
          value:       _directives.DirectiveLocation.FIELD,
          description: 'Location adjacent to a field.'
        },
        FRAGMENT_DEFINITION:    {
          value:       _directives.DirectiveLocation.FRAGMENT_DEFINITION,
          description: 'Location adjacent to a fragment definition.'
        },
        FRAGMENT_SPREAD:        {
          value:       _directives.DirectiveLocation.FRAGMENT_SPREAD,
          description: 'Location adjacent to a fragment spread.'
        },
        INLINE_FRAGMENT:        {
          value:       _directives.DirectiveLocation.INLINE_FRAGMENT,
          description: 'Location adjacent to an inline fragment.'
        },
        SCHEMA:                 {
          value:       _directives.DirectiveLocation.SCHEMA,
          description: 'Location adjacent to a schema definition.'
        },
        SCALAR:                 {
          value:       _directives.DirectiveLocation.SCALAR,
          description: 'Location adjacent to a scalar definition.'
        },
        OBJECT:                 {
          value:       _directives.DirectiveLocation.OBJECT,
          description: 'Location adjacent to an object type definition.'
        },
        FIELD_DEFINITION:       {
          value:       _directives.DirectiveLocation.FIELD_DEFINITION,
          description: 'Location adjacent to a field definition.'
        },
        ARGUMENT_DEFINITION:    {
          value:       _directives.DirectiveLocation.ARGUMENT_DEFINITION,
          description: 'Location adjacent to an argument definition.'
        },
        INTERFACE:              {
          value:       _directives.DirectiveLocation.INTERFACE,
          description: 'Location adjacent to an interface definition.'
        },
        UNION:                  {
          value:       _directives.DirectiveLocation.UNION,
          description: 'Location adjacent to a union definition.'
        },
        ENUM:                   {
          value:       _directives.DirectiveLocation.ENUM,
          description: 'Location adjacent to an enum definition.'
        },
        ENUM_VALUE:             {
          value:       _directives.DirectiveLocation.ENUM_VALUE,
          description: 'Location adjacent to an enum value definition.'
        },
        INPUT_OBJECT:           {
          value:       _directives.DirectiveLocation.INPUT_OBJECT,
          description: 'Location adjacent to an input object type definition.'
        },
        INPUT_FIELD_DEFINITION: {
          value:       _directives.DirectiveLocation.INPUT_FIELD_DEFINITION,
          description: 'Location adjacent to an input object field definition.'
        }
      }
    });

    var __Type = exports.__Type = new _definition.GraphQLObjectType({
      name:            '__Type',
      isIntrospection: true,
      description:     'The fundamental unit of any GraphQL Schema is the type. There are ' + 'many kinds of types in GraphQL as represented by the `__TypeKind` enum.' + '\n\nDepending on the kind of a type, certain fields describe ' + 'information about that type. Scalar types provide no information ' + 'beyond a name and description, while Enum types provide their values. ' + 'Object and Interface types provide the fields they describe. Abstract ' + 'types, Union and Interface, provide the Object types possible ' + 'at runtime. List and NonNull types compose other types.',
      fields:          function fields() {
        return {
          kind:          {
            type:    new _definition.GraphQLNonNull(__TypeKind),
            resolve: function resolve(type) {
              if (type instanceof _definition.GraphQLScalarType) {
                return TypeKind.SCALAR;
              } else if (type instanceof _definition.GraphQLObjectType) {
                return TypeKind.OBJECT;
              } else if (type instanceof _definition.GraphQLInterfaceType) {
                return TypeKind.INTERFACE;
              } else if (type instanceof _definition.GraphQLUnionType) {
                return TypeKind.UNION;
              } else if (type instanceof _definition.GraphQLEnumType) {
                return TypeKind.ENUM;
              } else if (type instanceof _definition.GraphQLInputObjectType) {
                return TypeKind.INPUT_OBJECT;
              } else if (type instanceof _definition.GraphQLList) {
                return TypeKind.LIST;
              } else if (type instanceof _definition.GraphQLNonNull) {
                return TypeKind.NON_NULL;
              }
              throw new Error('Unknown kind of type: ' + type);
            }
          },
          name:          { type: _scalars.GraphQLString },
          description:   { type: _scalars.GraphQLString },
          fields:        {
            type:    new _definition.GraphQLList(new _definition.GraphQLNonNull(__Field)),
            args:    {
              includeDeprecated: { type: _scalars.GraphQLBoolean, defaultValue: false }
            },
            resolve: function resolve(type, _ref) {
              var includeDeprecated = _ref.includeDeprecated;

              if (type instanceof _definition.GraphQLObjectType || type instanceof _definition.GraphQLInterfaceType) {
                var _ret = function() {
                  var fieldMap = type.getFields();
                  var fields = Object.keys(fieldMap).map(function(fieldName) {
                    return fieldMap[ fieldName ];
                  });
                  if (!includeDeprecated) {
                    fields = fields.filter(function(field) {
                      return !field.deprecationReason;
                    });
                  }
                  return {
                    v: fields
                  };
                }();

                if (typeof _ret === "object") return _ret.v;
              }
              return null;
            }
          },
          interfaces:    {
            type:    new _definition.GraphQLList(new _definition.GraphQLNonNull(__Type)),
            resolve: function resolve(type) {
              if (type instanceof _definition.GraphQLObjectType) {
                return type.getInterfaces();
              }
            }
          },
          possibleTypes: {
            type:    new _definition.GraphQLList(new _definition.GraphQLNonNull(__Type)),
            resolve: function resolve(type, args, context, _ref2) {
              var schema = _ref2.schema;

              if (type instanceof _definition.GraphQLInterfaceType || type instanceof _definition.GraphQLUnionType) {
                return schema.getPossibleTypes(type);
              }
            }
          },
          enumValues:    {
            type:    new _definition.GraphQLList(new _definition.GraphQLNonNull(__EnumValue)),
            args:    {
              includeDeprecated: { type: _scalars.GraphQLBoolean, defaultValue: false }
            },
            resolve: function resolve(type, _ref3) {
              var includeDeprecated = _ref3.includeDeprecated;

              if (type instanceof _definition.GraphQLEnumType) {
                var values = type.getValues();
                if (!includeDeprecated) {
                  values = values.filter(function(value) {
                    return !value.deprecationReason;
                  });
                }
                return values;
              }
            }
          },
          inputFields:   {
            type:    new _definition.GraphQLList(new _definition.GraphQLNonNull(__InputValue)),
            resolve: function resolve(type) {
              if (type instanceof _definition.GraphQLInputObjectType) {
                var _ret2 = function() {
                  var fieldMap = type.getFields();
                  return {
                    v: Object.keys(fieldMap).map(function(fieldName) {
                      return fieldMap[ fieldName ];
                    })
                  };
                }();

                if (typeof _ret2 === "object") return _ret2.v;
              }
            }
          },
          ofType:        { type: __Type }
        };
      }
    });

    var __Field = exports.__Field = new _definition.GraphQLObjectType({
      name:            '__Field',
      isIntrospection: true,
      description:     'Object and Interface types are described by a list of Fields, each of ' + 'which has a name, potentially a list of arguments, and a return type.',
      fields:          function fields() {
        return {
          name:              { type: new _definition.GraphQLNonNull(_scalars.GraphQLString) },
          description:       { type: _scalars.GraphQLString },
          args:              {
            type:    new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__InputValue))),
            resolve: function resolve(field) {
              return field.args || [];
            }
          },
          type:              { type: new _definition.GraphQLNonNull(__Type) },
          isDeprecated:      { type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean) },
          deprecationReason: {
            type: _scalars.GraphQLString
          }
        };
      }
    });

    var __InputValue = exports.__InputValue = new _definition.GraphQLObjectType({
      name:            '__InputValue',
      isIntrospection: true,
      description:     'Arguments provided to Fields or Directives and the input fields of an ' + 'InputObject are represented as Input Values which describe their type ' + 'and optionally a default value.',
      fields:          function fields() {
        return {
          name:         { type: new _definition.GraphQLNonNull(_scalars.GraphQLString) },
          description:  { type: _scalars.GraphQLString },
          type:         { type: new _definition.GraphQLNonNull(__Type) },
          defaultValue: {
            type:        _scalars.GraphQLString,
            description: 'A GraphQL-formatted string representing the default value for this ' + 'input value.',
            resolve:     function resolve(inputVal) {
              return (0, _isInvalid2.default)(inputVal.defaultValue) ? null : (0, _printer.print)((0, _astFromValue.astFromValue)(inputVal.defaultValue, inputVal.type));
            }
          }
        };
      }
    });

    var __EnumValue = exports.__EnumValue = new _definition.GraphQLObjectType({
      name:            '__EnumValue',
      isIntrospection: true,
      description:     'One possible value for a given Enum. Enum values are unique values, not ' + 'a placeholder for a string or numeric value. However an Enum value is ' + 'returned in a JSON response as a string.',
      fields:          function fields() {
        return {
          name:              { type: new _definition.GraphQLNonNull(_scalars.GraphQLString) },
          description:       { type: _scalars.GraphQLString },
          isDeprecated:      { type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean) },
          deprecationReason: {
            type: _scalars.GraphQLString
          }
        };
      }
    });

    var TypeKind = exports.TypeKind = {
      SCALAR:       'SCALAR',
      OBJECT:       'OBJECT',
      INTERFACE:    'INTERFACE',
      UNION:        'UNION',
      ENUM:         'ENUM',
      INPUT_OBJECT: 'INPUT_OBJECT',
      LIST:         'LIST',
      NON_NULL:     'NON_NULL'
    };

    var __TypeKind = exports.__TypeKind = new _definition.GraphQLEnumType({
      name:            '__TypeKind',
      isIntrospection: true,
      description:     'An enum describing what kind of type a given `__Type` is.',
      values:          {
        SCALAR:       {
          value:       TypeKind.SCALAR,
          description: 'Indicates this type is a scalar.'
        },
        OBJECT:       {
          value:       TypeKind.OBJECT,
          description: 'Indicates this type is an object. ' + '`fields` and `interfaces` are valid fields.'
        },
        INTERFACE:    {
          value:       TypeKind.INTERFACE,
          description: 'Indicates this type is an interface. ' + '`fields` and `possibleTypes` are valid fields.'
        },
        UNION:        {
          value:       TypeKind.UNION,
          description: 'Indicates this type is a union. ' + '`possibleTypes` is a valid field.'
        },
        ENUM:         {
          value:       TypeKind.ENUM,
          description: 'Indicates this type is an enum. ' + '`enumValues` is a valid field.'
        },
        INPUT_OBJECT: {
          value:       TypeKind.INPUT_OBJECT,
          description: 'Indicates this type is an input object. ' + '`inputFields` is a valid field.'
        },
        LIST:         {
          value:       TypeKind.LIST,
          description: 'Indicates this type is a list. ' + '`ofType` is a valid field.'
        },
        NON_NULL:     {
          value:       TypeKind.NON_NULL,
          description: 'Indicates this type is a non-null. ' + '`ofType` is a valid field.'
        }
      }
    });

    /**
     * Note that these are GraphQLField and not GraphQLFieldConfig,
     * so the format for args is different.
     */

    var SchemaMetaFieldDef = exports.SchemaMetaFieldDef = {
      name:        '__schema',
      type:        new _definition.GraphQLNonNull(__Schema),
      description: 'Access the current type schema of this server.',
      args:        [],
      resolve:     function resolve(source, args, context, _ref4) {
        var schema = _ref4.schema;
        return schema;
      }
    };

    var TypeMetaFieldDef = exports.TypeMetaFieldDef = {
      name:        '__type',
      type:        __Type,
      description: 'Request the type information of a single type.',
      args:        [ { name: 'name', type: new _definition.GraphQLNonNull(_scalars.GraphQLString) } ],
      resolve:     function resolve(source, _ref5, context, _ref6) {
        var name = _ref5.name;
        var schema = _ref6.schema;
        return schema.getType(name);
      }
    };

    var TypeNameMetaFieldDef = exports.TypeNameMetaFieldDef = {
      name:        '__typename',
      type:        new _definition.GraphQLNonNull(_scalars.GraphQLString),
      description: 'The name of the current Object type at runtime.',
      args:        [],
      resolve:     function resolve(source, args, context, _ref7) {
        var parentType = _ref7.parentType;
        return parentType.name;
      }
    };

    /***/
  }),
  /* 12 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = keyMap;

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    /**
     * Creates a keyed JS object from an array, given a function to produce the keys
     * for each value in the array.
     *
     * This provides a convenient lookup for the array items if the key function
     * produces unique results.
     *
     *     const phoneBook = [
     *       { name: 'Jon', num: '555-1234' },
     *       { name: 'Jenny', num: '867-5309' }
     *     ]
     *
     *     // { Jon: { name: 'Jon', num: '555-1234' },
 *     //   Jenny: { name: 'Jenny', num: '867-5309' } }
     *     const entriesByName = keyMap(
     *       phoneBook,
     *       entry => entry.name
     *     )
     *
     *     // { name: 'Jenny', num: '857-6309' }
     *     const jennyEntry = entriesByName['Jenny']
     *
     */
    function keyMap(list, keyFn) {
      return list.reduce(function(map, item) {
        return map[ keyFn(item) ] = item, map;
      }, {});
    }

    /***/
  }),
  /* 13 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.GraphQLError = GraphQLError;

    var _location = __webpack_require__(25);

    /**
     * A GraphQLError describes an Error found during the parse, validate, or
     * execute phases of performing a GraphQL operation. In addition to a message
     * and stack trace, it also includes information about the locations in a
     * GraphQL document and/or execution result that correspond to the Error.
     */
    function GraphQLError( // eslint-disable-line no-redeclare
      message, nodes, source, positions, path, originalError) {
      // Include (non-enumerable) stack trace.
      if (originalError && originalError.stack) {
        Object.defineProperty(this, 'stack', {
          value:        originalError.stack,
          writable:     true,
          configurable: true
        });
      } else if (Error.captureStackTrace) {
        Error.captureStackTrace(this, GraphQLError);
      } else {
        Object.defineProperty(this, 'stack', {
          value:        Error().stack,
          writable:     true,
          configurable: true
        });
      }

      // Compute locations in the source for the given nodes/positions.
      var _source = source;
      if (!_source && nodes && nodes.length > 0) {
        var node = nodes[ 0 ];
        _source = node && node.loc && node.loc.source;
      }

      var _positions = positions;
      if (!_positions && nodes) {
        _positions = nodes.filter(function(node) {
          return Boolean(node.loc);
        }).map(function(node) {
          return node.loc.start;
        });
      }
      if (_positions && _positions.length === 0) {
        _positions = undefined;
      }

      var _locations = void 0;
      var _source2 = _source; // seems here Flow need a const to resolve type.
      if (_source2 && _positions) {
        _locations = _positions.map(function(pos) {
          return (0, _location.getLocation)(_source2, pos);
        });
      }

      Object.defineProperties(this, {
        message:       {
          value:      message,
          // By being enumerable, JSON.stringify will include `message` in the
          // resulting output. This ensures that the simplist possible GraphQL
          // service adheres to the spec.
          enumerable: true,
          writable:   true
        },
        locations:     {
          // Coercing falsey values to undefined ensures they will not be included
          // in JSON.stringify() when not provided.
          value:      _locations || undefined,
          // By being enumerable, JSON.stringify will include `locations` in the
          // resulting output. This ensures that the simplist possible GraphQL
          // service adheres to the spec.
          enumerable: true
        },
        path:          {
          // Coercing falsey values to undefined ensures they will not be included
          // in JSON.stringify() when not provided.
          value:      path || undefined,
          // By being enumerable, JSON.stringify will include `path` in the
          // resulting output. This ensures that the simplist possible GraphQL
          // service adheres to the spec.
          enumerable: true
        },
        nodes:         {
          value: nodes || undefined
        },
        source:        {
          value: _source || undefined
        },
        positions:     {
          value: _positions || undefined
        },
        originalError: {
          value: originalError
        }
      });
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    GraphQLError.prototype = Object.create(Error.prototype, {
      constructor: { value: GraphQLError },
      name:        { value: 'GraphQLError' }
    });

    /***/
  }),
  /* 14 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isInvalid;

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    /**
     * Returns true if a value is undefined, or NaN.
     */
    function isInvalid(value) {
      return value === undefined || value !== value;
    }

    /***/
  }),
  /* 15 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.visit = visit;
    exports.visitInParallel = visitInParallel;
    exports.visitWithTypeInfo = visitWithTypeInfo;
    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    var QueryDocumentKeys = exports.QueryDocumentKeys = {
      Name: [],

      Document:            [ 'definitions' ],
      OperationDefinition: [ 'name', 'variableDefinitions', 'directives', 'selectionSet' ],
      VariableDefinition:  [ 'variable', 'type', 'defaultValue' ],
      Variable:            [ 'name' ],
      SelectionSet:        [ 'selections' ],
      Field:               [ 'alias', 'name', 'arguments', 'directives', 'selectionSet' ],
      Argument:            [ 'name', 'value' ],

      FragmentSpread:     [ 'name', 'directives' ],
      InlineFragment:     [ 'typeCondition', 'directives', 'selectionSet' ],
      FragmentDefinition: [ 'name', 'typeCondition', 'directives', 'selectionSet' ],

      IntValue:     [],
      FloatValue:   [],
      StringValue:  [],
      BooleanValue: [],
      NullValue:    [],
      EnumValue:    [],
      ListValue:    [ 'values' ],
      ObjectValue:  [ 'fields' ],
      ObjectField:  [ 'name', 'value' ],

      Directive: [ 'name', 'arguments' ],

      NamedType:   [ 'name' ],
      ListType:    [ 'type' ],
      NonNullType: [ 'type' ],

      SchemaDefinition:        [ 'directives', 'operationTypes' ],
      OperationTypeDefinition: [ 'type' ],

      ScalarTypeDefinition:      [ 'name', 'directives' ],
      ObjectTypeDefinition:      [ 'name', 'interfaces', 'directives', 'fields' ],
      FieldDefinition:           [ 'name', 'arguments', 'type', 'directives' ],
      InputValueDefinition:      [ 'name', 'type', 'defaultValue', 'directives' ],
      InterfaceTypeDefinition:   [ 'name', 'directives', 'fields' ],
      UnionTypeDefinition:       [ 'name', 'directives', 'types' ],
      EnumTypeDefinition:        [ 'name', 'directives', 'values' ],
      EnumValueDefinition:       [ 'name', 'directives' ],
      InputObjectTypeDefinition: [ 'name', 'directives', 'fields' ],

      TypeExtensionDefinition: [ 'definition' ],

      DirectiveDefinition: [ 'name', 'arguments', 'locations' ]
    };

    var BREAK = exports.BREAK = {};

    /**
     * visit() will walk through an AST using a depth first traversal, calling
     * the visitor's enter function at each node in the traversal, and calling the
     * leave function after visiting that node and all of its child nodes.
     *
     * By returning different values from the enter and leave functions, the
     * behavior of the visitor can be altered, including skipping over a sub-tree of
     * the AST (by returning false), editing the AST by returning a value or null
     * to remove the value, or to stop the whole traversal by returning BREAK.
     *
     * When using visit() to edit an AST, the original AST will not be modified, and
     * a new version of the AST with the changes applied will be returned from the
     * visit function.
     *
     *     const editedAST = visit(ast, {
 *       enter(node, key, parent, path, ancestors) {
 *         // @return
 *         //   undefined: no action
 *         //   false: skip visiting this node
 *         //   visitor.BREAK: stop visiting altogether
 *         //   null: delete this node
 *         //   any value: replace this node with the returned value
 *       },
 *       leave(node, key, parent, path, ancestors) {
 *         // @return
 *         //   undefined: no action
 *         //   false: no action
 *         //   visitor.BREAK: stop visiting altogether
 *         //   null: delete this node
 *         //   any value: replace this node with the returned value
 *       }
 *     });
     *
     * Alternatively to providing enter() and leave() functions, a visitor can
     * instead provide functions named the same as the kinds of AST nodes, or
     * enter/leave visitors at a named key, leading to four permutations of
     * visitor API:
     *
     * 1) Named visitors triggered when entering a node a specific kind.
     *
     *     visit(ast, {
 *       Kind(node) {
 *         // enter the "Kind" node
 *       }
 *     })
     *
     * 2) Named visitors that trigger upon entering and leaving a node of
     *    a specific kind.
     *
     *     visit(ast, {
 *       Kind: {
 *         enter(node) {
 *           // enter the "Kind" node
 *         }
 *         leave(node) {
 *           // leave the "Kind" node
 *         }
 *       }
 *     })
     *
     * 3) Generic visitors that trigger upon entering and leaving any node.
     *
     *     visit(ast, {
 *       enter(node) {
 *         // enter any node
 *       },
 *       leave(node) {
 *         // leave any node
 *       }
 *     })
     *
     * 4) Parallel visitors for entering and leaving nodes of a specific kind.
     *
     *     visit(ast, {
 *       enter: {
 *         Kind(node) {
 *           // enter the "Kind" node
 *         }
 *       },
 *       leave: {
 *         Kind(node) {
 *           // leave the "Kind" node
 *         }
 *       }
 *     })
     */
    function visit(root, visitor, keyMap) {
      var visitorKeys = keyMap || QueryDocumentKeys;

      var stack = void 0;
      var inArray = Array.isArray(root);
      var keys = [ root ];
      var index = -1;
      var edits = [];
      var parent = void 0;
      var path = [];
      var ancestors = [];
      var newRoot = root;

      do {
        index++;
        var isLeaving = index === keys.length;
        var key = void 0;
        var node = void 0;
        var isEdited = isLeaving && edits.length !== 0;
        if (isLeaving) {
          key = ancestors.length === 0 ? undefined : path.pop();
          node = parent;
          parent = ancestors.pop();
          if (isEdited) {
            if (inArray) {
              node = node.slice();
            } else {
              var clone = {};
              for (var k in node) {
                if (node.hasOwnProperty(k)) {
                  clone[ k ] = node[ k ];
                }
              }
              node = clone;
            }
            var editOffset = 0;
            for (var ii = 0; ii < edits.length; ii++) {
              var editKey = edits[ ii ][ 0 ];
              var editValue = edits[ ii ][ 1 ];
              if (inArray) {
                editKey -= editOffset;
              }
              if (inArray && editValue === null) {
                node.splice(editKey, 1);
                editOffset++;
              } else {
                node[ editKey ] = editValue;
              }
            }
          }
          index = stack.index;
          keys = stack.keys;
          edits = stack.edits;
          inArray = stack.inArray;
          stack = stack.prev;
        } else {
          key = parent ? inArray ? index : keys[ index ] : undefined;
          node = parent ? parent[ key ] : newRoot;
          if (node === null || node === undefined) {
            continue;
          }
          if (parent) {
            path.push(key);
          }
        }

        var result = void 0;
        if (!Array.isArray(node)) {
          if (!isNode(node)) {
            throw new Error('Invalid AST Node: ' + JSON.stringify(node));
          }
          var visitFn = getVisitFn(visitor, node.kind, isLeaving);
          if (visitFn) {
            result = visitFn.call(visitor, node, key, parent, path, ancestors);

            if (result === BREAK) {
              break;
            }

            if (result === false) {
              if (!isLeaving) {
                path.pop();
                continue;
              }
            } else if (result !== undefined) {
              edits.push([ key, result ]);
              if (!isLeaving) {
                if (isNode(result)) {
                  node = result;
                } else {
                  path.pop();
                  continue;
                }
              }
            }
          }
        }

        if (result === undefined && isEdited) {
          edits.push([ key, node ]);
        }

        if (!isLeaving) {
          stack = { inArray: inArray, index: index, keys: keys, edits: edits, prev: stack };
          inArray = Array.isArray(node);
          keys = inArray ? node : visitorKeys[ node.kind ] || [];
          index = -1;
          edits = [];
          if (parent) {
            ancestors.push(parent);
          }
          parent = node;
        }
      } while (stack !== undefined);

      if (edits.length !== 0) {
        newRoot = edits[ edits.length - 1 ][ 1 ];
      }

      return newRoot;
    }

    function isNode(maybeNode) {
      return maybeNode && typeof maybeNode.kind === 'string';
    }

    /**
     * Creates a new visitor instance which delegates to many visitors to run in
     * parallel. Each visitor will be visited for each node before moving on.
     *
     * If a prior visitor edits a node, no following visitors will see that node.
     */
    function visitInParallel(visitors) {
      var skipping = new Array(visitors.length);

      return {
        enter: function enter(node) {
          for (var i = 0; i < visitors.length; i++) {
            if (!skipping[ i ]) {
              var fn = getVisitFn(visitors[ i ], node.kind, /* isLeaving */false);
              if (fn) {
                var result = fn.apply(visitors[ i ], arguments);
                if (result === false) {
                  skipping[ i ] = node;
                } else if (result === BREAK) {
                  skipping[ i ] = BREAK;
                } else if (result !== undefined) {
                  return result;
                }
              }
            }
          }
        },
        leave: function leave(node) {
          for (var i = 0; i < visitors.length; i++) {
            if (!skipping[ i ]) {
              var fn = getVisitFn(visitors[ i ], node.kind, /* isLeaving */true);
              if (fn) {
                var result = fn.apply(visitors[ i ], arguments);
                if (result === BREAK) {
                  skipping[ i ] = BREAK;
                } else if (result !== undefined && result !== false) {
                  return result;
                }
              }
            } else if (skipping[ i ] === node) {
              skipping[ i ] = null;
            }
          }
        }
      };
    }

    /**
     * Creates a new visitor instance which maintains a provided TypeInfo instance
     * along with visiting visitor.
     */
    function visitWithTypeInfo(typeInfo, visitor) {
      return {
        enter: function enter(node) {
          typeInfo.enter(node);
          var fn = getVisitFn(visitor, node.kind, /* isLeaving */false);
          if (fn) {
            var result = fn.apply(visitor, arguments);
            if (result !== undefined) {
              typeInfo.leave(node);
              if (isNode(result)) {
                typeInfo.enter(result);
              }
            }
            return result;
          }
        },
        leave: function leave(node) {
          var fn = getVisitFn(visitor, node.kind, /* isLeaving */true);
          var result = void 0;
          if (fn) {
            result = fn.apply(visitor, arguments);
          }
          typeInfo.leave(node);
          return result;
        }
      };
    }

    /**
     * Given a visitor instance, if it is leaving or not, and a node kind, return
     * the function the visitor runtime should call.
     */
    function getVisitFn(visitor, kind, isLeaving) {
      var kindVisitor = visitor[ kind ];
      if (kindVisitor) {
        if (!isLeaving && typeof kindVisitor === 'function') {
          // { Kind() {} }
          return kindVisitor;
        }
        var kindSpecificVisitor = isLeaving ? kindVisitor.leave : kindVisitor.enter;
        if (typeof kindSpecificVisitor === 'function') {
          // { Kind: { enter() {}, leave() {} } }
          return kindSpecificVisitor;
        }
      } else {
        var specificVisitor = isLeaving ? visitor.leave : visitor.enter;
        if (specificVisitor) {
          if (typeof specificVisitor === 'function') {
            // { enter() {}, leave() {} }
            return specificVisitor;
          }
          var specificKindVisitor = specificVisitor[ kind ];
          if (typeof specificKindVisitor === 'function') {
            // { enter: { Kind() {} }, leave: { Kind() {} } }
            return specificKindVisitor;
          }
        }
      }
    }

    /***/
  }),
  /* 16 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.valueFromAST = valueFromAST;

    var _keyMap = __webpack_require__(12);

    var _keyMap2 = _interopRequireDefault(_keyMap);

    var _invariant = __webpack_require__(3);

    var _invariant2 = _interopRequireDefault(_invariant);

    var _isNullish = __webpack_require__(6);

    var _isNullish2 = _interopRequireDefault(_isNullish);

    var _isInvalid = __webpack_require__(14);

    var _isInvalid2 = _interopRequireDefault(_isInvalid);

    var _kinds = __webpack_require__(2);

    var Kind = _interopRequireWildcard(_kinds);

    var _definition = __webpack_require__(1);

    function _interopRequireWildcard(obj) {
      if (obj && obj.__esModule) {
        return obj;
      } else {
        var newObj = {};
        if (obj != null) {
          for (var key in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[ key ] = obj[ key ];
          }
        }
        newObj.default = obj;
        return newObj;
      }
    }

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    /**
     * Produces a JavaScript value given a GraphQL Value AST.
     *
     * A GraphQL type must be provided, which will be used to interpret different
     * GraphQL Value literals.
     *
     * Returns `undefined` when the value could not be validly coerced according to
     * the provided type.
     *
     * | GraphQL Value        | JSON Value    |
     * | -------------------- | ------------- |
     * | Input Object         | Object        |
     * | List                 | Array         |
     * | Boolean              | Boolean       |
     * | String               | String        |
     * | Int / Float          | Number        |
     * | Enum Value           | Mixed         |
     * | NullValue            | null          |
     *
     */

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function valueFromAST(valueNode, type, variables) {
      if (!valueNode) {
        // When there is no node, then there is also no value.
        // Importantly, this is different from returning the value null.
        return;
      }

      if (type instanceof _definition.GraphQLNonNull) {
        if (valueNode.kind === Kind.NULL) {
          return; // Invalid: intentionally return no value.
        }
        return valueFromAST(valueNode, type.ofType, variables);
      }

      if (valueNode.kind === Kind.NULL) {
        // This is explicitly returning the value null.
        return null;
      }

      if (valueNode.kind === Kind.VARIABLE) {
        var variableName = valueNode.name.value;
        if (!variables || (0, _isInvalid2.default)(variables[ variableName ])) {
          // No valid return value.
          return;
        }
        // Note: we're not doing any checking that this variable is correct. We're
        // assuming that this query has been validated and the variable usage here
        // is of the correct type.
        return variables[ variableName ];
      }

      if (type instanceof _definition.GraphQLList) {
        var itemType = type.ofType;
        if (valueNode.kind === Kind.LIST) {
          var coercedValues = [];
          var itemNodes = valueNode.values;
          for (var i = 0; i < itemNodes.length; i++) {
            if (isMissingVariable(itemNodes[ i ], variables)) {
              // If an array contains a missing variable, it is either coerced to
              // null or if the item type is non-null, it considered invalid.
              if (itemType instanceof _definition.GraphQLNonNull) {
                return; // Invalid: intentionally return no value.
              }
              coercedValues.push(null);
            } else {
              var itemValue = valueFromAST(itemNodes[ i ], itemType, variables);
              if ((0, _isInvalid2.default)(itemValue)) {
                return; // Invalid: intentionally return no value.
              }
              coercedValues.push(itemValue);
            }
          }
          return coercedValues;
        }
        var coercedValue = valueFromAST(valueNode, itemType, variables);
        if ((0, _isInvalid2.default)(coercedValue)) {
          return; // Invalid: intentionally return no value.
        }
        return [ coercedValue ];
      }

      if (type instanceof _definition.GraphQLInputObjectType) {
        if (valueNode.kind !== Kind.OBJECT) {
          return; // Invalid: intentionally return no value.
        }
        var coercedObj = Object.create(null);
        var fields = type.getFields();
        var fieldNodes = (0, _keyMap2.default)(valueNode.fields, function(field) {
          return field.name.value;
        });
        var fieldNames = Object.keys(fields);
        for (var _i = 0; _i < fieldNames.length; _i++) {
          var fieldName = fieldNames[ _i ];
          var field = fields[ fieldName ];
          var fieldNode = fieldNodes[ fieldName ];
          if (!fieldNode || isMissingVariable(fieldNode.value, variables)) {
            if (!(0, _isInvalid2.default)(field.defaultValue)) {
              coercedObj[ fieldName ] = field.defaultValue;
            } else if (field.type instanceof _definition.GraphQLNonNull) {
              return; // Invalid: intentionally return no value.
            }
            continue;
          }
          var fieldValue = valueFromAST(fieldNode.value, field.type, variables);
          if ((0, _isInvalid2.default)(fieldValue)) {
            return; // Invalid: intentionally return no value.
          }
          coercedObj[ fieldName ] = fieldValue;
        }
        return coercedObj;
      }

      (0, _invariant2.default)(type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType, 'Must be input type');

      var parsed = type.parseLiteral(valueNode);
      if ((0, _isNullish2.default)(parsed)) {
        // null or invalid values represent a failure to parse correctly,
        // in which case no value is returned.
        return;
      }

      return parsed;
    }

// Returns true if the provided valueNode is a variable which is not defined
// in the set of variables.
    function isMissingVariable(valueNode, variables) {
      return valueNode.kind === Kind.VARIABLE && (!variables || (0, _isInvalid2.default)(variables[ valueNode.name.value ]));
    }

    /***/
  }),
  /* 17 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.parse = parse;
    exports.parseValue = parseValue;
    exports.parseType = parseType;
    exports.parseConstValue = parseConstValue;
    exports.parseTypeReference = parseTypeReference;
    exports.parseNamedType = parseNamedType;

    var _source = __webpack_require__(26);

    var _error = __webpack_require__(0);

    var _lexer = __webpack_require__(24);

    var _kinds = __webpack_require__(2);

    /**
     * Given a GraphQL source, parses it into a Document.
     * Throws GraphQLError if a syntax error is encountered.
     */

    /**
     * Configuration options to control parser behavior
     */

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function parse(source, options) {
      var sourceObj = typeof source === 'string' ? new _source.Source(source) : source;
      var lexer = (0, _lexer.createLexer)(sourceObj, options || {});
      return parseDocument(lexer);
    }

    /**
     * Given a string containing a GraphQL value (ex. `[42]`), parse the AST for
     * that value.
     * Throws GraphQLError if a syntax error is encountered.
     *
     * This is useful within tools that operate upon GraphQL Values directly and
     * in isolation of complete GraphQL documents.
     *
     * Consider providing the results to the utility function: valueFromAST().
     */
    function parseValue(source, options) {
      var sourceObj = typeof source === 'string' ? new _source.Source(source) : source;
      var lexer = (0, _lexer.createLexer)(sourceObj, options || {});
      expect(lexer, _lexer.TokenKind.SOF);
      var value = parseValueLiteral(lexer, false);
      expect(lexer, _lexer.TokenKind.EOF);
      return value;
    }

    /**
     * Given a string containing a GraphQL Type (ex. `[Int!]`), parse the AST for
     * that type.
     * Throws GraphQLError if a syntax error is encountered.
     *
     * This is useful within tools that operate upon GraphQL Types directly and
     * in isolation of complete GraphQL documents.
     *
     * Consider providing the results to the utility function: typeFromAST().
     */
    function parseType(source, options) {
      var sourceObj = typeof source === 'string' ? new _source.Source(source) : source;
      var lexer = (0, _lexer.createLexer)(sourceObj, options || {});
      expect(lexer, _lexer.TokenKind.SOF);
      var type = parseTypeReference(lexer);
      expect(lexer, _lexer.TokenKind.EOF);
      return type;
    }

    /**
     * Converts a name lex token into a name parse node.
     */
    function parseName(lexer) {
      var token = expect(lexer, _lexer.TokenKind.NAME);
      return {
        kind:  _kinds.NAME,
        value: token.value,
        loc:   loc(lexer, token)
      };
    }

// Implements the parsing rules in the Document section.

    /**
     * Document : Definition+
     */
    function parseDocument(lexer) {
      var start = lexer.token;
      expect(lexer, _lexer.TokenKind.SOF);
      var definitions = [];
      do {
        definitions.push(parseDefinition(lexer));
      } while (!skip(lexer, _lexer.TokenKind.EOF));

      return {
        kind:        _kinds.DOCUMENT,
        definitions: definitions,
        loc:         loc(lexer, start)
      };
    }

    /**
     * Definition :
     *   - OperationDefinition
     *   - FragmentDefinition
     *   - TypeSystemDefinition
     */
    function parseDefinition(lexer) {
      if (peek(lexer, _lexer.TokenKind.BRACE_L)) {
        return parseOperationDefinition(lexer);
      }

      if (peek(lexer, _lexer.TokenKind.NAME)) {
        switch (lexer.token.value) {
          // Note: subscription is an experimental non-spec addition.
          case 'query':
          case 'mutation':
          case 'subscription':
            return parseOperationDefinition(lexer);

          case 'fragment':
            return parseFragmentDefinition(lexer);

          // Note: the Type System IDL is an experimental non-spec addition.
          case 'schema':
          case 'scalar':
          case 'type':
          case 'interface':
          case 'union':
          case 'enum':
          case 'input':
          case 'extend':
          case 'directive':
            return parseTypeSystemDefinition(lexer);
        }
      }

      throw unexpected(lexer);
    }

// Implements the parsing rules in the Operations section.

    /**
     * OperationDefinition :
     *  - SelectionSet
     *  - OperationType Name? VariableDefinitions? Directives? SelectionSet
     */
    function parseOperationDefinition(lexer) {
      var start = lexer.token;
      if (peek(lexer, _lexer.TokenKind.BRACE_L)) {
        return {
          kind:                _kinds.OPERATION_DEFINITION,
          operation:           'query',
          name:                null,
          variableDefinitions: null,
          directives:          [],
          selectionSet:        parseSelectionSet(lexer),
          loc:                 loc(lexer, start)
        };
      }
      var operation = parseOperationType(lexer);
      var name = void 0;
      if (peek(lexer, _lexer.TokenKind.NAME)) {
        name = parseName(lexer);
      }
      return {
        kind:                _kinds.OPERATION_DEFINITION,
        operation:           operation,
        name:                name,
        variableDefinitions: parseVariableDefinitions(lexer),
        directives:          parseDirectives(lexer),
        selectionSet:        parseSelectionSet(lexer),
        loc:                 loc(lexer, start)
      };
    }

    /**
     * OperationType : one of query mutation subscription
     */
    function parseOperationType(lexer) {
      var operationToken = expect(lexer, _lexer.TokenKind.NAME);
      switch (operationToken.value) {
        case 'query':
          return 'query';
        case 'mutation':
          return 'mutation';
        // Note: subscription is an experimental non-spec addition.
        case 'subscription':
          return 'subscription';
      }

      throw unexpected(lexer, operationToken);
    }

    /**
     * VariableDefinitions : ( VariableDefinition+ )
     */
    function parseVariableDefinitions(lexer) {
      return peek(lexer, _lexer.TokenKind.PAREN_L) ? many(lexer, _lexer.TokenKind.PAREN_L, parseVariableDefinition, _lexer.TokenKind.PAREN_R) : [];
    }

    /**
     * VariableDefinition : Variable : Type DefaultValue?
     */
    function parseVariableDefinition(lexer) {
      var start = lexer.token;
      return {
        kind:         _kinds.VARIABLE_DEFINITION,
        variable:     parseVariable(lexer),
        type:         (expect(lexer, _lexer.TokenKind.COLON), parseTypeReference(lexer)),
        defaultValue: skip(lexer, _lexer.TokenKind.EQUALS) ? parseValueLiteral(lexer, true) : null,
        loc:          loc(lexer, start)
      };
    }

    /**
     * Variable : $ Name
     */
    function parseVariable(lexer) {
      var start = lexer.token;
      expect(lexer, _lexer.TokenKind.DOLLAR);
      return {
        kind: _kinds.VARIABLE,
        name: parseName(lexer),
        loc:  loc(lexer, start)
      };
    }

    /**
     * SelectionSet : { Selection+ }
     */
    function parseSelectionSet(lexer) {
      var start = lexer.token;
      return {
        kind:       _kinds.SELECTION_SET,
        selections: many(lexer, _lexer.TokenKind.BRACE_L, parseSelection, _lexer.TokenKind.BRACE_R),
        loc:        loc(lexer, start)
      };
    }

    /**
     * Selection :
     *   - Field
     *   - FragmentSpread
     *   - InlineFragment
     */
    function parseSelection(lexer) {
      return peek(lexer, _lexer.TokenKind.SPREAD) ? parseFragment(lexer) : parseField(lexer);
    }

    /**
     * Field : Alias? Name Arguments? Directives? SelectionSet?
     *
     * Alias : Name :
     */
    function parseField(lexer) {
      var start = lexer.token;

      var nameOrAlias = parseName(lexer);
      var alias = void 0;
      var name = void 0;
      if (skip(lexer, _lexer.TokenKind.COLON)) {
        alias = nameOrAlias;
        name = parseName(lexer);
      } else {
        alias = null;
        name = nameOrAlias;
      }

      return {
        kind:         _kinds.FIELD,
        alias:        alias,
        name:         name,
        arguments:    parseArguments(lexer),
        directives:   parseDirectives(lexer),
        selectionSet: peek(lexer, _lexer.TokenKind.BRACE_L) ? parseSelectionSet(lexer) : null,
        loc:          loc(lexer, start)
      };
    }

    /**
     * Arguments : ( Argument+ )
     */
    function parseArguments(lexer) {
      return peek(lexer, _lexer.TokenKind.PAREN_L) ? many(lexer, _lexer.TokenKind.PAREN_L, parseArgument, _lexer.TokenKind.PAREN_R) : [];
    }

    /**
     * Argument : Name : Value
     */
    function parseArgument(lexer) {
      var start = lexer.token;
      return {
        kind:  _kinds.ARGUMENT,
        name:  parseName(lexer),
        value: (expect(lexer, _lexer.TokenKind.COLON), parseValueLiteral(lexer, false)),
        loc:   loc(lexer, start)
      };
    }

// Implements the parsing rules in the Fragments section.

    /**
     * Corresponds to both FragmentSpread and InlineFragment in the spec.
     *
     * FragmentSpread : ... FragmentName Directives?
     *
     * InlineFragment : ... TypeCondition? Directives? SelectionSet
     */
    function parseFragment(lexer) {
      var start = lexer.token;
      expect(lexer, _lexer.TokenKind.SPREAD);
      if (peek(lexer, _lexer.TokenKind.NAME) && lexer.token.value !== 'on') {
        return {
          kind:       _kinds.FRAGMENT_SPREAD,
          name:       parseFragmentName(lexer),
          directives: parseDirectives(lexer),
          loc:        loc(lexer, start)
        };
      }
      var typeCondition = null;
      if (lexer.token.value === 'on') {
        lexer.advance();
        typeCondition = parseNamedType(lexer);
      }
      return {
        kind:          _kinds.INLINE_FRAGMENT,
        typeCondition: typeCondition,
        directives:    parseDirectives(lexer),
        selectionSet:  parseSelectionSet(lexer),
        loc:           loc(lexer, start)
      };
    }

    /**
     * FragmentDefinition :
     *   - fragment FragmentName on TypeCondition Directives? SelectionSet
     *
     * TypeCondition : NamedType
     */
    function parseFragmentDefinition(lexer) {
      var start = lexer.token;
      expectKeyword(lexer, 'fragment');
      return {
        kind:          _kinds.FRAGMENT_DEFINITION,
        name:          parseFragmentName(lexer),
        typeCondition: (expectKeyword(lexer, 'on'), parseNamedType(lexer)),
        directives:    parseDirectives(lexer),
        selectionSet:  parseSelectionSet(lexer),
        loc:           loc(lexer, start)
      };
    }

    /**
     * FragmentName : Name but not `on`
     */
    function parseFragmentName(lexer) {
      if (lexer.token.value === 'on') {
        throw unexpected(lexer);
      }
      return parseName(lexer);
    }

// Implements the parsing rules in the Values section.

    /**
     * Value[Const] :
     *   - [~Const] Variable
     *   - IntValue
     *   - FloatValue
     *   - StringValue
     *   - BooleanValue
     *   - NullValue
     *   - EnumValue
     *   - ListValue[?Const]
     *   - ObjectValue[?Const]
     *
     * BooleanValue : one of `true` `false`
     *
     * NullValue : `null`
     *
     * EnumValue : Name but not `true`, `false` or `null`
     */
    function parseValueLiteral(lexer, isConst) {
      var token = lexer.token;
      switch (token.kind) {
        case _lexer.TokenKind.BRACKET_L:
          return parseList(lexer, isConst);
        case _lexer.TokenKind.BRACE_L:
          return parseObject(lexer, isConst);
        case _lexer.TokenKind.INT:
          lexer.advance();
          return {
            kind:  _kinds.INT,
            value: token.value,
            loc:   loc(lexer, token)
          };
        case _lexer.TokenKind.FLOAT:
          lexer.advance();
          return {
            kind:  _kinds.FLOAT,
            value: token.value,
            loc:   loc(lexer, token)
          };
        case _lexer.TokenKind.STRING:
          lexer.advance();
          return {
            kind:  _kinds.STRING,
            value: token.value,
            loc:   loc(lexer, token)
          };
        case _lexer.TokenKind.NAME:
          if (token.value === 'true' || token.value === 'false') {
            lexer.advance();
            return {
              kind:  _kinds.BOOLEAN,
              value: token.value === 'true',
              loc:   loc(lexer, token)
            };
          } else if (token.value === 'null') {
            lexer.advance();
            return {
              kind: _kinds.NULL,
              loc:  loc(lexer, token)
            };
          }
          lexer.advance();
          return {
            kind:  _kinds.ENUM,
            value: token.value,
            loc:   loc(lexer, token)
          };
        case _lexer.TokenKind.DOLLAR:
          if (!isConst) {
            return parseVariable(lexer);
          }
          break;
      }
      throw unexpected(lexer);
    }

    function parseConstValue(lexer) {
      return parseValueLiteral(lexer, true);
    }

    function parseValueValue(lexer) {
      return parseValueLiteral(lexer, false);
    }

    /**
     * ListValue[Const] :
     *   - [ ]
     *   - [ Value[?Const]+ ]
     */
    function parseList(lexer, isConst) {
      var start = lexer.token;
      var item = isConst ? parseConstValue : parseValueValue;
      return {
        kind:   _kinds.LIST,
        values: any(lexer, _lexer.TokenKind.BRACKET_L, item, _lexer.TokenKind.BRACKET_R),
        loc:    loc(lexer, start)
      };
    }

    /**
     * ObjectValue[Const] :
     *   - { }
     *   - { ObjectField[?Const]+ }
     */
    function parseObject(lexer, isConst) {
      var start = lexer.token;
      expect(lexer, _lexer.TokenKind.BRACE_L);
      var fields = [];
      while (!skip(lexer, _lexer.TokenKind.BRACE_R)) {
        fields.push(parseObjectField(lexer, isConst));
      }
      return {
        kind:   _kinds.OBJECT,
        fields: fields,
        loc:    loc(lexer, start)
      };
    }

    /**
     * ObjectField[Const] : Name : Value[?Const]
     */
    function parseObjectField(lexer, isConst) {
      var start = lexer.token;
      return {
        kind:  _kinds.OBJECT_FIELD,
        name:  parseName(lexer),
        value: (expect(lexer, _lexer.TokenKind.COLON), parseValueLiteral(lexer, isConst)),
        loc:   loc(lexer, start)
      };
    }

// Implements the parsing rules in the Directives section.

    /**
     * Directives : Directive+
     */
    function parseDirectives(lexer) {
      var directives = [];
      while (peek(lexer, _lexer.TokenKind.AT)) {
        directives.push(parseDirective(lexer));
      }
      return directives;
    }

    /**
     * Directive : @ Name Arguments?
     */
    function parseDirective(lexer) {
      var start = lexer.token;
      expect(lexer, _lexer.TokenKind.AT);
      return {
        kind:      _kinds.DIRECTIVE,
        name:      parseName(lexer),
        arguments: parseArguments(lexer),
        loc:       loc(lexer, start)
      };
    }

// Implements the parsing rules in the Types section.

    /**
     * Type :
     *   - NamedType
     *   - ListType
     *   - NonNullType
     */
    function parseTypeReference(lexer) {
      var start = lexer.token;
      var type = void 0;
      if (skip(lexer, _lexer.TokenKind.BRACKET_L)) {
        type = parseTypeReference(lexer);
        expect(lexer, _lexer.TokenKind.BRACKET_R);
        type = {
          kind: _kinds.LIST_TYPE,
          type: type,
          loc:  loc(lexer, start)
        };
      } else {
        type = parseNamedType(lexer);
      }
      if (skip(lexer, _lexer.TokenKind.BANG)) {
        return {
          kind: _kinds.NON_NULL_TYPE,
          type: type,
          loc:  loc(lexer, start)
        };
      }
      return type;
    }

    /**
     * NamedType : Name
     */
    function parseNamedType(lexer) {
      var start = lexer.token;
      return {
        kind: _kinds.NAMED_TYPE,
        name: parseName(lexer),
        loc:  loc(lexer, start)
      };
    }

// Implements the parsing rules in the Type Definition section.

    /**
     * TypeSystemDefinition :
     *   - SchemaDefinition
     *   - TypeDefinition
     *   - TypeExtensionDefinition
     *   - DirectiveDefinition
     *
     * TypeDefinition :
     *   - ScalarTypeDefinition
     *   - ObjectTypeDefinition
     *   - InterfaceTypeDefinition
     *   - UnionTypeDefinition
     *   - EnumTypeDefinition
     *   - InputObjectTypeDefinition
     */
    function parseTypeSystemDefinition(lexer) {
      if (peek(lexer, _lexer.TokenKind.NAME)) {
        switch (lexer.token.value) {
          case 'schema':
            return parseSchemaDefinition(lexer);
          case 'scalar':
            return parseScalarTypeDefinition(lexer);
          case 'type':
            return parseObjectTypeDefinition(lexer);
          case 'interface':
            return parseInterfaceTypeDefinition(lexer);
          case 'union':
            return parseUnionTypeDefinition(lexer);
          case 'enum':
            return parseEnumTypeDefinition(lexer);
          case 'input':
            return parseInputObjectTypeDefinition(lexer);
          case 'extend':
            return parseTypeExtensionDefinition(lexer);
          case 'directive':
            return parseDirectiveDefinition(lexer);
        }
      }

      throw unexpected(lexer);
    }

    /**
     * SchemaDefinition : schema Directives? { OperationTypeDefinition+ }
     *
     * OperationTypeDefinition : OperationType : NamedType
     */
    function parseSchemaDefinition(lexer) {
      var start = lexer.token;
      expectKeyword(lexer, 'schema');
      var directives = parseDirectives(lexer);
      var operationTypes = many(lexer, _lexer.TokenKind.BRACE_L, parseOperationTypeDefinition, _lexer.TokenKind.BRACE_R);
      return {
        kind:           _kinds.SCHEMA_DEFINITION,
        directives:     directives,
        operationTypes: operationTypes,
        loc:            loc(lexer, start)
      };
    }

    function parseOperationTypeDefinition(lexer) {
      var start = lexer.token;
      var operation = parseOperationType(lexer);
      expect(lexer, _lexer.TokenKind.COLON);
      var type = parseNamedType(lexer);
      return {
        kind:      _kinds.OPERATION_TYPE_DEFINITION,
        operation: operation,
        type:      type,
        loc:       loc(lexer, start)
      };
    }

    /**
     * ScalarTypeDefinition : scalar Name Directives?
     */
    function parseScalarTypeDefinition(lexer) {
      var start = lexer.token;
      expectKeyword(lexer, 'scalar');
      var name = parseName(lexer);
      var directives = parseDirectives(lexer);
      return {
        kind:       _kinds.SCALAR_TYPE_DEFINITION,
        name:       name,
        directives: directives,
        loc:        loc(lexer, start)
      };
    }

    /**
     * ObjectTypeDefinition :
     *   - type Name ImplementsInterfaces? Directives? { FieldDefinition+ }
     */
    function parseObjectTypeDefinition(lexer) {
      var start = lexer.token;
      expectKeyword(lexer, 'type');
      var name = parseName(lexer);
      var interfaces = parseImplementsInterfaces(lexer);
      var directives = parseDirectives(lexer);
      var fields = any(lexer, _lexer.TokenKind.BRACE_L, parseFieldDefinition, _lexer.TokenKind.BRACE_R);
      return {
        kind:       _kinds.OBJECT_TYPE_DEFINITION,
        name:       name,
        interfaces: interfaces,
        directives: directives,
        fields:     fields,
        loc:        loc(lexer, start)
      };
    }

    /**
     * ImplementsInterfaces : implements NamedType+
     */
    function parseImplementsInterfaces(lexer) {
      var types = [];
      if (lexer.token.value === 'implements') {
        lexer.advance();
        do {
          types.push(parseNamedType(lexer));
        } while (peek(lexer, _lexer.TokenKind.NAME));
      }
      return types;
    }

    /**
     * FieldDefinition : Name ArgumentsDefinition? : Type Directives?
     */
    function parseFieldDefinition(lexer) {
      var start = lexer.token;
      var name = parseName(lexer);
      var args = parseArgumentDefs(lexer);
      expect(lexer, _lexer.TokenKind.COLON);
      var type = parseTypeReference(lexer);
      var directives = parseDirectives(lexer);
      return {
        kind:       _kinds.FIELD_DEFINITION,
        name:       name,
        arguments:  args,
        type:       type,
        directives: directives,
        loc:        loc(lexer, start)
      };
    }

    /**
     * ArgumentsDefinition : ( InputValueDefinition+ )
     */
    function parseArgumentDefs(lexer) {
      if (!peek(lexer, _lexer.TokenKind.PAREN_L)) {
        return [];
      }
      return many(lexer, _lexer.TokenKind.PAREN_L, parseInputValueDef, _lexer.TokenKind.PAREN_R);
    }

    /**
     * InputValueDefinition : Name : Type DefaultValue? Directives?
     */
    function parseInputValueDef(lexer) {
      var start = lexer.token;
      var name = parseName(lexer);
      expect(lexer, _lexer.TokenKind.COLON);
      var type = parseTypeReference(lexer);
      var defaultValue = null;
      if (skip(lexer, _lexer.TokenKind.EQUALS)) {
        defaultValue = parseConstValue(lexer);
      }
      var directives = parseDirectives(lexer);
      return {
        kind:         _kinds.INPUT_VALUE_DEFINITION,
        name:         name,
        type:         type,
        defaultValue: defaultValue,
        directives:   directives,
        loc:          loc(lexer, start)
      };
    }

    /**
     * InterfaceTypeDefinition : interface Name Directives? { FieldDefinition+ }
     */
    function parseInterfaceTypeDefinition(lexer) {
      var start = lexer.token;
      expectKeyword(lexer, 'interface');
      var name = parseName(lexer);
      var directives = parseDirectives(lexer);
      var fields = any(lexer, _lexer.TokenKind.BRACE_L, parseFieldDefinition, _lexer.TokenKind.BRACE_R);
      return {
        kind:       _kinds.INTERFACE_TYPE_DEFINITION,
        name:       name,
        directives: directives,
        fields:     fields,
        loc:        loc(lexer, start)
      };
    }

    /**
     * UnionTypeDefinition : union Name Directives? = UnionMembers
     */
    function parseUnionTypeDefinition(lexer) {
      var start = lexer.token;
      expectKeyword(lexer, 'union');
      var name = parseName(lexer);
      var directives = parseDirectives(lexer);
      expect(lexer, _lexer.TokenKind.EQUALS);
      var types = parseUnionMembers(lexer);
      return {
        kind:       _kinds.UNION_TYPE_DEFINITION,
        name:       name,
        directives: directives,
        types:      types,
        loc:        loc(lexer, start)
      };
    }

    /**
     * UnionMembers :
     *   - NamedType
     *   - UnionMembers | NamedType
     */
    function parseUnionMembers(lexer) {
      var members = [];
      do {
        members.push(parseNamedType(lexer));
      } while (skip(lexer, _lexer.TokenKind.PIPE));
      return members;
    }

    /**
     * EnumTypeDefinition : enum Name Directives? { EnumValueDefinition+ }
     */
    function parseEnumTypeDefinition(lexer) {
      var start = lexer.token;
      expectKeyword(lexer, 'enum');
      var name = parseName(lexer);
      var directives = parseDirectives(lexer);
      var values = many(lexer, _lexer.TokenKind.BRACE_L, parseEnumValueDefinition, _lexer.TokenKind.BRACE_R);
      return {
        kind:       _kinds.ENUM_TYPE_DEFINITION,
        name:       name,
        directives: directives,
        values:     values,
        loc:        loc(lexer, start)
      };
    }

    /**
     * EnumValueDefinition : EnumValue Directives?
     *
     * EnumValue : Name
     */
    function parseEnumValueDefinition(lexer) {
      var start = lexer.token;
      var name = parseName(lexer);
      var directives = parseDirectives(lexer);
      return {
        kind:       _kinds.ENUM_VALUE_DEFINITION,
        name:       name,
        directives: directives,
        loc:        loc(lexer, start)
      };
    }

    /**
     * InputObjectTypeDefinition : input Name Directives? { InputValueDefinition+ }
     */
    function parseInputObjectTypeDefinition(lexer) {
      var start = lexer.token;
      expectKeyword(lexer, 'input');
      var name = parseName(lexer);
      var directives = parseDirectives(lexer);
      var fields = any(lexer, _lexer.TokenKind.BRACE_L, parseInputValueDef, _lexer.TokenKind.BRACE_R);
      return {
        kind:       _kinds.INPUT_OBJECT_TYPE_DEFINITION,
        name:       name,
        directives: directives,
        fields:     fields,
        loc:        loc(lexer, start)
      };
    }

    /**
     * TypeExtensionDefinition : extend ObjectTypeDefinition
     */
    function parseTypeExtensionDefinition(lexer) {
      var start = lexer.token;
      expectKeyword(lexer, 'extend');
      var definition = parseObjectTypeDefinition(lexer);
      return {
        kind:       _kinds.TYPE_EXTENSION_DEFINITION,
        definition: definition,
        loc:        loc(lexer, start)
      };
    }

    /**
     * DirectiveDefinition :
     *   - directive @ Name ArgumentsDefinition? on DirectiveLocations
     */
    function parseDirectiveDefinition(lexer) {
      var start = lexer.token;
      expectKeyword(lexer, 'directive');
      expect(lexer, _lexer.TokenKind.AT);
      var name = parseName(lexer);
      var args = parseArgumentDefs(lexer);
      expectKeyword(lexer, 'on');
      var locations = parseDirectiveLocations(lexer);
      return {
        kind:      _kinds.DIRECTIVE_DEFINITION,
        name:      name,
        arguments: args,
        locations: locations,
        loc:       loc(lexer, start)
      };
    }

    /**
     * DirectiveLocations :
     *   - Name
     *   - DirectiveLocations | Name
     */
    function parseDirectiveLocations(lexer) {
      var locations = [];
      do {
        locations.push(parseName(lexer));
      } while (skip(lexer, _lexer.TokenKind.PIPE));
      return locations;
    }

// Core parsing utility functions

    /**
     * Returns a location object, used to identify the place in
     * the source that created a given parsed object.
     */
    function loc(lexer, startToken) {
      if (!lexer.options.noLocation) {
        return new Loc(startToken, lexer.lastToken, lexer.source);
      }
    }

    function Loc(startToken, endToken, source) {
      this.start = startToken.start;
      this.end = endToken.end;
      this.startToken = startToken;
      this.endToken = endToken;
      this.source = source;
    }

// Print a simplified form when appearing in JSON/util.inspect.
    Loc.prototype.toJSON = Loc.prototype.inspect = function toJSON() {
      return { start: this.start, end: this.end };
    };

    /**
     * Determines if the next token is of a given kind
     */
    function peek(lexer, kind) {
      return lexer.token.kind === kind;
    }

    /**
     * If the next token is of the given kind, return true after advancing
     * the lexer. Otherwise, do not change the parser state and return false.
     */
    function skip(lexer, kind) {
      var match = lexer.token.kind === kind;
      if (match) {
        lexer.advance();
      }
      return match;
    }

    /**
     * If the next token is of the given kind, return that token after advancing
     * the lexer. Otherwise, do not change the parser state and throw an error.
     */
    function expect(lexer, kind) {
      var token = lexer.token;
      if (token.kind === kind) {
        lexer.advance();
        return token;
      }
      throw (0, _error.syntaxError)(lexer.source, token.start, 'Expected ' + kind + ', found ' + (0, _lexer.getTokenDesc)(token));
    }

    /**
     * If the next token is a keyword with the given value, return that token after
     * advancing the lexer. Otherwise, do not change the parser state and return
     * false.
     */
    function expectKeyword(lexer, value) {
      var token = lexer.token;
      if (token.kind === _lexer.TokenKind.NAME && token.value === value) {
        lexer.advance();
        return token;
      }
      throw (0, _error.syntaxError)(lexer.source, token.start, 'Expected "' + value + '", found ' + (0, _lexer.getTokenDesc)(token));
    }

    /**
     * Helper function for creating an error when an unexpected lexed token
     * is encountered.
     */
    function unexpected(lexer, atToken) {
      var token = atToken || lexer.token;
      return (0, _error.syntaxError)(lexer.source, token.start, 'Unexpected ' + (0, _lexer.getTokenDesc)(token));
    }

    /**
     * Returns a possibly empty list of parse nodes, determined by
     * the parseFn. This list begins with a lex token of openKind
     * and ends with a lex token of closeKind. Advances the parser
     * to the next lex token after the closing token.
     */
    function any(lexer, openKind, parseFn, closeKind) {
      expect(lexer, openKind);
      var nodes = [];
      while (!skip(lexer, closeKind)) {
        nodes.push(parseFn(lexer));
      }
      return nodes;
    }

    /**
     * Returns a non-empty list of parse nodes, determined by
     * the parseFn. This list begins with a lex token of openKind
     * and ends with a lex token of closeKind. Advances the parser
     * to the next lex token after the closing token.
     */
    function many(lexer, openKind, parseFn, closeKind) {
      expect(lexer, openKind);
      var nodes = [ parseFn(lexer) ];
      while (!skip(lexer, closeKind)) {
        nodes.push(parseFn(lexer));
      }
      return nodes;
    }

    /***/
  }),
  /* 18 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.isValidLiteralValue = isValidLiteralValue;

    var _printer = __webpack_require__(4);

    var _kinds = __webpack_require__(2);

    var _definition = __webpack_require__(1);

    var _invariant = __webpack_require__(3);

    var _invariant2 = _interopRequireDefault(_invariant);

    var _keyMap = __webpack_require__(12);

    var _keyMap2 = _interopRequireDefault(_keyMap);

    var _isNullish = __webpack_require__(6);

    var _isNullish2 = _interopRequireDefault(_isNullish);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    /**
     * Utility for validators which determines if a value literal node is valid
     * given an input type.
     *
     * Note that this only validates literal values, variables are assumed to
     * provide values of the correct type.
     */

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function isValidLiteralValue(type, valueNode) {
      // A value must be provided if the type is non-null.
      if (type instanceof _definition.GraphQLNonNull) {
        if (!valueNode || valueNode.kind === _kinds.NULL) {
          return [ 'Expected "' + String(type) + '", found null.' ];
        }
        return isValidLiteralValue(type.ofType, valueNode);
      }

      if (!valueNode || valueNode.kind === _kinds.NULL) {
        return [];
      }

      // This function only tests literals, and assumes variables will provide
      // values of the correct type.
      if (valueNode.kind === _kinds.VARIABLE) {
        return [];
      }

      // Lists accept a non-list value as a list of one.
      if (type instanceof _definition.GraphQLList) {
        var _ret = function() {
          var itemType = type.ofType;
          if (valueNode.kind === _kinds.LIST) {
            return {
              v: valueNode.values.reduce(function(acc, item, index) {
                var errors = isValidLiteralValue(itemType, item);
                return acc.concat(errors.map(function(error) {
                  return 'In element #' + index + ': ' + error;
                }));
              }, [])
            };
          }
          return {
            v: isValidLiteralValue(itemType, valueNode)
          };
        }();

        if (typeof _ret === "object") return _ret.v;
      }

      // Input objects check each defined field and look for undefined fields.
      if (type instanceof _definition.GraphQLInputObjectType) {
        var _ret2 = function() {
          if (valueNode.kind !== _kinds.OBJECT) {
            return {
              v: [ 'Expected "' + type.name + '", found not an object.' ]
            };
          }
          var fields = type.getFields();

          var errors = [];

          // Ensure every provided field is defined.
          var fieldNodes = valueNode.fields;
          fieldNodes.forEach(function(providedFieldNode) {
            if (!fields[ providedFieldNode.name.value ]) {
              errors.push('In field "' + providedFieldNode.name.value + '": Unknown field.');
            }
          });

          // Ensure every defined field is valid.
          var fieldNodeMap = (0, _keyMap2.default)(fieldNodes, function(fieldNode) {
            return fieldNode.name.value;
          });
          Object.keys(fields).forEach(function(fieldName) {
            var result = isValidLiteralValue(fields[ fieldName ].type, fieldNodeMap[ fieldName ] && fieldNodeMap[ fieldName ].value);
            errors.push.apply(errors, result.map(function(error) {
              return 'In field "' + fieldName + '": ' + error;
            }));
          });

          return {
            v: errors
          };
        }();

        if (typeof _ret2 === "object") return _ret2.v;
      }

      (0, _invariant2.default)(type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType, 'Must be input type');

      // Scalar/Enum input checks to ensure the type can parse the value to
      // a non-null value.
      var parseResult = type.parseLiteral(valueNode);
      if ((0, _isNullish2.default)(parseResult)) {
        return [ 'Expected type "' + type.name + '", found ' + (0, _printer.print)(valueNode) + '.' ];
      }

      return [];
    }

    /***/
  }),
  /* 19 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.isEqualType = isEqualType;
    exports.isTypeSubTypeOf = isTypeSubTypeOf;
    exports.doTypesOverlap = doTypesOverlap;

    var _definition = __webpack_require__(1);

    /**
     * Provided two types, return true if the types are equal (invariant).
     */
    function isEqualType(typeA, typeB) {
      // Equivalent types are equal.
      if (typeA === typeB) {
        return true;
      }

      // If either type is non-null, the other must also be non-null.
      if (typeA instanceof _definition.GraphQLNonNull && typeB instanceof _definition.GraphQLNonNull) {
        return isEqualType(typeA.ofType, typeB.ofType);
      }

      // If either type is a list, the other must also be a list.
      if (typeA instanceof _definition.GraphQLList && typeB instanceof _definition.GraphQLList) {
        return isEqualType(typeA.ofType, typeB.ofType);
      }

      // Otherwise the types are not equal.
      return false;
    }

    /**
     * Provided a type and a super type, return true if the first type is either
     * equal or a subset of the second super type (covariant).
     */

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function isTypeSubTypeOf(schema, maybeSubType, superType) {
      // Equivalent type is a valid subtype
      if (maybeSubType === superType) {
        return true;
      }

      // If superType is non-null, maybeSubType must also be non-null.
      if (superType instanceof _definition.GraphQLNonNull) {
        if (maybeSubType instanceof _definition.GraphQLNonNull) {
          return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
        }
        return false;
      } else if (maybeSubType instanceof _definition.GraphQLNonNull) {
        // If superType is nullable, maybeSubType may be non-null or nullable.
        return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);
      }

      // If superType type is a list, maybeSubType type must also be a list.
      if (superType instanceof _definition.GraphQLList) {
        if (maybeSubType instanceof _definition.GraphQLList) {
          return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
        }
        return false;
      } else if (maybeSubType instanceof _definition.GraphQLList) {
        // If superType is not a list, maybeSubType must also be not a list.
        return false;
      }

      // If superType type is an abstract type, maybeSubType type may be a currently
      // possible object type.
      if ((0, _definition.isAbstractType)(superType) && maybeSubType instanceof _definition.GraphQLObjectType && schema.isPossibleType(superType, maybeSubType)) {
        return true;
      }

      // Otherwise, the child type is not a valid subtype of the parent type.
      return false;
    }

    /**
     * Provided two composite types, determine if they "overlap". Two composite
     * types overlap when the Sets of possible concrete types for each intersect.
     *
     * This is often used to determine if a fragment of a given type could possibly
     * be visited in a context of another type.
     *
     * This function is commutative.
     */
    function doTypesOverlap(schema, typeA, typeB) {
      // So flow is aware this is constant
      var _typeB = typeB;

      // Equivalent types overlap
      if (typeA === _typeB) {
        return true;
      }

      if (typeA instanceof _definition.GraphQLInterfaceType || typeA instanceof _definition.GraphQLUnionType) {
        if (_typeB instanceof _definition.GraphQLInterfaceType || _typeB instanceof _definition.GraphQLUnionType) {
          // If both types are abstract, then determine if there is any intersection
          // between possible concrete types of each.
          return schema.getPossibleTypes(typeA).some(function(type) {
            return schema.isPossibleType(_typeB, type);
          });
        }
        // Determine if the latter type is a possible concrete type of the former.
        return schema.isPossibleType(typeA, _typeB);
      }

      if (_typeB instanceof _definition.GraphQLInterfaceType || _typeB instanceof _definition.GraphQLUnionType) {
        // Determine if the former type is a possible concrete type of the latter.
        return schema.isPossibleType(_typeB, typeA);
      }

      // Otherwise the types do not overlap.
      return false;
    }

    /***/
  }),
  /* 20 */
  /***/ (function(module, exports) {

    /**
     * Copyright (c) 2016, Lee Byron
     * All rights reserved.
     *
     * This source code is licensed under the MIT license found in the
     * LICENSE file in the root directory of this source tree.
     *
     * @ignore
     */

    /**
     * [Iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterator)
     * is a *protocol* which describes a standard way to produce a sequence of
     * values, typically the values of the Iterable represented by this Iterator.
     *
     * While described by the [ES2015 version of JavaScript](http://www.ecma-international.org/ecma-262/6.0/#sec-iterator-interface)
     * it can be utilized by any version of JavaScript.
     *
     * @typedef {Object} Iterator
     * @template T The type of each iterated value
     * @property {function (): { value: T, done: boolean }} next
     *   A method which produces either the next value in a sequence or a result
     *   where the `done` property is `true` indicating the end of the Iterator.
     */

    /**
     * [Iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable)
     * is a *protocol* which when implemented allows a JavaScript object to define
     * their iteration behavior, such as what values are looped over in a `for..of`
     * loop or `iterall`'s `forEach` function. Many [built-in types](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#Builtin_iterables)
     * implement the Iterable protocol, including `Array` and `Map`.
     *
     * While described by the [ES2015 version of JavaScript](http://www.ecma-international.org/ecma-262/6.0/#sec-iterable-interface)
     * it can be utilized by any version of JavaScript.
     *
     * @typedef {Object} Iterable
     * @template T The type of each iterated value
     * @property {function (): Iterator<T>} Symbol.iterator
     *   A method which produces an Iterator for this Iterable.
     */

// In ES2015 (or a polyfilled) environment, this will be Symbol.iterator
    var SYMBOL_ITERATOR = typeof Symbol === 'function' && Symbol.iterator

    /**
     * A property name to be used as the name of an Iterable's method responsible
     * for producing an Iterator, referred to as `@@iterator`. Typically represents
     * the value `Symbol.iterator` but falls back to the string `"@@iterator"` when
     * `Symbol.iterator` is not defined.
     *
     * Use `$$iterator` for defining new Iterables instead of `Symbol.iterator`,
     * but do not use it for accessing existing Iterables, instead use
     * `getIterator()` or `isIterable()`.
     *
     * @example
     *
     * var $$iterator = require('iterall').$$iterator
     *
     * function Counter (to) {
 *   this.to = to
 * }
     *
     * Counter.prototype[$$iterator] = function () {
 *   return {
 *     to: this.to,
 *     num: 0,
 *     next () {
 *       if (this.num >= this.to) {
 *         return { value: undefined, done: true }
 *       }
 *       return { value: this.num++, done: false }
 *     }
 *   }
 * }
     *
     * var counter = new Counter(3)
     * for (var number of counter) {
 *   console.log(number) // 0 ... 1 ... 2
 * }
     *
     * @type {Symbol|string}
     */
    var $$iterator = SYMBOL_ITERATOR || '@@iterator'
    exports.$$iterator = $$iterator

    /**
     * Returns true if the provided object implements the Iterator protocol via
     * either implementing a `Symbol.iterator` or `"@@iterator"` method.
     *
     * @example
     *
     * var isIterable = require('iterall').isIterable
     * isIterable([ 1, 2, 3 ]) // true
     * isIterable('ABC') // true
     * isIterable({ length: 1, 0: 'Alpha' }) // false
     * isIterable({ key: 'value' }) // false
     * isIterable(new Map()) // true
     *
     * @param obj
     *   A value which might implement the Iterable protocol.
     * @return {boolean} true if Iterable.
     */
    function isIterable(obj) {
      return !!getIteratorMethod(obj)
    }

    exports.isIterable = isIterable

    /**
     * Returns true if the provided object implements the Array-like protocol via
     * defining a positive-integer `length` property.
     *
     * @example
     *
     * var isArrayLike = require('iterall').isArrayLike
     * isArrayLike([ 1, 2, 3 ]) // true
     * isArrayLike('ABC') // true
     * isArrayLike({ length: 1, 0: 'Alpha' }) // true
     * isArrayLike({ key: 'value' }) // false
     * isArrayLike(new Map()) // false
     *
     * @param obj
     *   A value which might implement the Array-like protocol.
     * @return {boolean} true if Array-like.
     */
    function isArrayLike(obj) {
      var length = obj != null && obj.length
      return typeof length === 'number' && length >= 0 && length % 1 === 0
    }

    exports.isArrayLike = isArrayLike

    /**
     * Returns true if the provided object is an Object (i.e. not a string literal)
     * and is either Iterable or Array-like.
     *
     * This may be used in place of [Array.isArray()][isArray] to determine if an
     * object should be iterated-over. It always excludes string literals and
     * includes Arrays (regardless of if it is Iterable). It also includes other
     * Array-like objects such as NodeList, TypedArray, and Buffer.
     *
     * @example
     *
     * var isCollection = require('iterall').isCollection
     * isCollection([ 1, 2, 3 ]) // true
     * isCollection('ABC') // false
     * isCollection({ length: 1, 0: 'Alpha' }) // true
     * isCollection({ key: 'value' }) // false
     * isCollection(new Map()) // true
     *
     * @example
     *
     * var forEach = require('iterall').forEach
     * if (isCollection(obj)) {
 *   forEach(obj, function (value) {
 *     console.log(value)
 *   })
 * }
     *
     * @param obj
     *   An Object value which might implement the Iterable or Array-like protocols.
     * @return {boolean} true if Iterable or Array-like Object.
     */
    function isCollection(obj) {
      return Object(obj) === obj && (isArrayLike(obj) || isIterable(obj))
    }

    exports.isCollection = isCollection

    /**
     * If the provided object implements the Iterator protocol, its Iterator object
     * is returned. Otherwise returns undefined.
     *
     * @example
     *
     * var getIterator = require('iterall').getIterator
     * var iterator = getIterator([ 1, 2, 3 ])
     * iterator.next() // { value: 1, done: false }
     * iterator.next() // { value: 2, done: false }
     * iterator.next() // { value: 3, done: false }
     * iterator.next() // { value: undefined, done: true }
     *
     * @template T the type of each iterated value
     * @param {Iterable<T>} iterable
     *   An Iterable object which is the source of an Iterator.
     * @return {Iterator<T>} new Iterator instance.
     */
    function getIterator(iterable) {
      var method = getIteratorMethod(iterable)
      if (method) {
        return method.call(iterable)
      }
    }

    exports.getIterator = getIterator

    /**
     * If the provided object implements the Iterator protocol, the method
     * responsible for producing its Iterator object is returned.
     *
     * This is used in rare cases for performance tuning. This method must be called
     * with obj as the contextual this-argument.
     *
     * @example
     *
     * var getIteratorMethod = require('iterall').getIteratorMethod
     * var myArray = [ 1, 2, 3 ]
     * var method = getIteratorMethod(myArray)
     * if (method) {
 *   var iterator = method.call(myArray)
 * }
     *
     * @template T the type of each iterated value
     * @param {Iterable<T>} iterable
     *   An Iterable object which defines an `@@iterator` method.
     * @return {function(): Iterator<T>} `@@iterator` method.
     */
    function getIteratorMethod(iterable) {
      if (iterable != null) {
        var method = SYMBOL_ITERATOR && iterable[ SYMBOL_ITERATOR ] || iterable[ '@@iterator' ]
        if (typeof method === 'function') {
          return method
        }
      }
    }

    exports.getIteratorMethod = getIteratorMethod

    /**
     * Given an object which either implements the Iterable protocol or is
     * Array-like, iterate over it, calling the `callback` at each iteration.
     *
     * Use `forEach` where you would expect to use a `for ... of` loop in ES6.
     * However `forEach` adheres to the behavior of [Array#forEach][] described in
     * the ECMAScript specification, skipping over "holes" in Array-likes. It will
     * also delegate to a `forEach` method on `collection` if one is defined,
     * ensuring native performance for `Arrays`.
     *
     * Similar to [Array#forEach][], the `callback` function accepts three
     * arguments, and is provided with `thisArg` as the calling context.
     *
     * Note: providing an infinite Iterator to forEach will produce an error.
     *
     * [Array#forEach]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach
     *
     * @example
     *
     * var forEach = require('iterall').forEach
     *
     * forEach(myIterable, function (value, index, iterable) {
 *   console.log(value, index, iterable === myIterable)
 * })
     *
     * @example
     *
     * // ES6:
     * for (let value of myIterable) {
 *   console.log(value)
 * }
     *
     * // Any JavaScript environment:
     * forEach(myIterable, function (value) {
 *   console.log(value)
 * })
     *
     * @template T the type of each iterated value
     * @param {Iterable<T>|{ length: number }} collection
     *   The Iterable or array to iterate over.
     * @param {function(T, number, object)} callback
     *   Function to execute for each iteration, taking up to three arguments
     * @param [thisArg]
     *   Optional. Value to use as `this` when executing `callback`.
     */
    function forEach(collection, callback, thisArg) {
      if (collection != null) {
        if (typeof collection.forEach === 'function') {
          return collection.forEach(callback, thisArg)
        }
        var i = 0
        var iterator = getIterator(collection)
        if (iterator) {
          var step
          while (!(step = iterator.next()).done) {
            callback.call(thisArg, step.value, i++, collection)
            // Infinite Iterators could cause forEach to run forever.
            // After a very large number of iterations, produce an error.
            /* istanbul ignore if */
            if (i > 9999999) {
              throw new TypeError('Near-infinite iteration.')
            }
          }
        } else if (isArrayLike(collection)) {
          for (; i < collection.length; i++) {
            if (collection.hasOwnProperty(i)) {
              callback.call(thisArg, collection[ i ], i, collection)
            }
          }
        }
      }
    }

    exports.forEach = forEach

    /**
     * Similar to `getIterator()`, this method returns a new Iterator given an
     * Iterable. However it will also create an Iterator for a non-Iterable
     * Array-like collection, such as Array in a non-ES2015 environment.
     *
     * `createIterator` is complimentary to `forEach`, but allows a "pull"-based
     * iteration as opposed to `forEach`'s "push"-based iteration.
     *
     * `createIterator` produces an Iterator for Array-likes with the same behavior
     * as ArrayIteratorPrototype described in the ECMAScript specification, and
     * does *not* skip over "holes".
     *
     * @example
     *
     * var createIterator = require('iterall').createIterator
     *
     * var myArraylike = { length: 3, 0: 'Alpha', 1: 'Bravo', 2: 'Charlie' }
     * var iterator = createIterator(myArraylike)
     * iterator.next() // { value: 'Alpha', done: false }
     * iterator.next() // { value: 'Bravo', done: false }
     * iterator.next() // { value: 'Charlie', done: false }
     * iterator.next() // { value: undefined, done: true }
     *
     * @template T the type of each iterated value
     * @param {Iterable<T>|{ length: number }} collection
     *   An Iterable or Array-like object to produce an Iterator.
     * @return {Iterator<T>} new Iterator instance.
     */
    function createIterator(collection) {
      if (collection != null) {
        var iterator = getIterator(collection)
        if (iterator) {
          return iterator
        }
        if (isArrayLike(collection)) {
          return new ArrayLikeIterator(collection)
        }
      }
    }

    exports.createIterator = createIterator

// When the object provided to `createIterator` is not Iterable but is
// Array-like, this simple Iterator is created.
    function ArrayLikeIterator(obj) {
      this._o = obj
      this._i = 0
    }

// Note: all Iterators are themselves Iterable.
    ArrayLikeIterator.prototype[ $$iterator ] = function() {
      return this
    }

// A simple state-machine determines the IteratorResult returned, yielding
// each value in the Array-like object in order of their indicies.
    ArrayLikeIterator.prototype.next = function() {
      if (this._o === void 0 || this._i >= this._o.length) {
        this._o = void 0
        return { value: void 0, done: true }
      }
      return { value: this._o[ this._i++ ], done: false }
    }

    /***/
  }),
  /* 21 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = keyValMap;

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    /**
     * Creates a keyed JS object from an array, given a function to produce the keys
     * and a function to produce the values from each item in the array.
     *
     *     const phoneBook = [
     *       { name: 'Jon', num: '555-1234' },
     *       { name: 'Jenny', num: '867-5309' }
     *     ]
     *
     *     // { Jon: '555-1234', Jenny: '867-5309' }
     *     const phonesByName = keyValMap(
     *       phoneBook,
     *       entry => entry.name,
     *       entry => entry.num
     *     )
     *
     */
    function keyValMap(list, keyFn, valFn) {
      return list.reduce(function(map, item) {
        return map[ keyFn(item) ] = valFn(item), map;
      }, {});
    }

    /***/
  }),
  /* 22 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = quotedOrList;

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    var MAX_LENGTH = 5;

    /**
     * Given [ A, B, C ] return '"A", "B", or "C"'.
     */
    function quotedOrList(items) {
      var selected = items.slice(0, MAX_LENGTH);
      return selected.map(function(item) {
        return '"' + item + '"';
      }).reduce(function(list, quoted, index) {
        return list + (selected.length > 2 ? ', ' : ' ') + (index === selected.length - 1 ? 'or ' : '') + quoted;
      });
    }

    /***/
  }),
  /* 23 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = suggestionList;

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    /**
     * Given an invalid input string and a list of valid options, returns a filtered
     * list of valid options sorted based on their similarity with the input.
     */
    function suggestionList(input, options) {
      var optionsByDistance = Object.create(null);
      var oLength = options.length;
      var inputThreshold = input.length / 2;
      for (var i = 0; i < oLength; i++) {
        var distance = lexicalDistance(input, options[ i ]);
        var threshold = Math.max(inputThreshold, options[ i ].length / 2, 1);
        if (distance <= threshold) {
          optionsByDistance[ options[ i ] ] = distance;
        }
      }
      return Object.keys(optionsByDistance).sort(function(a, b) {
        return optionsByDistance[ a ] - optionsByDistance[ b ];
      });
    }

    /**
     * Computes the lexical distance between strings A and B.
     *
     * The "distance" between two strings is given by counting the minimum number
     * of edits needed to transform string A into string B. An edit can be an
     * insertion, deletion, or substitution of a single character, or a swap of two
     * adjacent characters.
     *
     * This distance can be useful for detecting typos in input or sorting
     *
     * @param {string} a
     * @param {string} b
     * @return {int} distance in number of edits
     */
    function lexicalDistance(a, b) {
      var i = void 0;
      var j = void 0;
      var d = [];
      var aLength = a.length;
      var bLength = b.length;

      for (i = 0; i <= aLength; i++) {
        d[ i ] = [ i ];
      }

      for (j = 1; j <= bLength; j++) {
        d[ 0 ][ j ] = j;
      }

      for (i = 1; i <= aLength; i++) {
        for (j = 1; j <= bLength; j++) {
          var cost = a[ i - 1 ] === b[ j - 1 ] ? 0 : 1;

          d[ i ][ j ] = Math.min(d[ i - 1 ][ j ] + 1, d[ i ][ j - 1 ] + 1, d[ i - 1 ][ j - 1 ] + cost);

          if (i > 1 && j > 1 && a[ i - 1 ] === b[ j - 2 ] && a[ i - 2 ] === b[ j - 1 ]) {
            d[ i ][ j ] = Math.min(d[ i ][ j ], d[ i - 2 ][ j - 2 ] + cost);
          }
        }
      }

      return d[ aLength ][ bLength ];
    }

    /***/
  }),
  /* 24 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.TokenKind = undefined;
    exports.createLexer = createLexer;
    exports.getTokenDesc = getTokenDesc;

    var _error = __webpack_require__(0);

    /**
     * Given a Source object, this returns a Lexer for that source.
     * A Lexer is a stateful stream generator in that every time
     * it is advanced, it returns the next token in the Source. Assuming the
     * source lexes, the final Token emitted by the lexer will be of kind
     * EOF, after which the lexer will repeatedly return the same EOF token
     * whenever called.
     */
    function createLexer(source, options) {
      var startOfFileToken = new Tok(SOF, 0, 0, 0, 0, null);
      var lexer = {
        source:    source,
        options:   options,
        lastToken: startOfFileToken,
        token:     startOfFileToken,
        line:      1,
        lineStart: 0,
        advance:   advanceLexer
      };
      return lexer;
    }

    /*  /
     /**
      *  Copyright (c) 2015, Facebook, Inc.
      *  All rights reserved.
      *
      *  This source code is licensed under the BSD-style license found in the
      *  LICENSE file in the root directory of this source tree. An additional grant
      *  of patent rights can be found in the PATENTS file in the same directory.
      */

    function advanceLexer() {
      var token = this.lastToken = this.token;
      if (token.kind !== EOF) {
        do {
          token = token.next = readToken(this, token);
        } while (token.kind === COMMENT);
        this.token = token;
      }
      return token;
    }

    /**
     * The return type of createLexer.
     */


// Each kind of token.
    var SOF = '<SOF>';
    var EOF = '<EOF>';
    var BANG = '!';
    var DOLLAR = '$';
    var PAREN_L = '(';
    var PAREN_R = ')';
    var SPREAD = '...';
    var COLON = ':';
    var EQUALS = '=';
    var AT = '@';
    var BRACKET_L = '[';
    var BRACKET_R = ']';
    var BRACE_L = '{';
    var PIPE = '|';
    var BRACE_R = '}';
    var NAME = 'Name';
    var INT = 'Int';
    var FLOAT = 'Float';
    var STRING = 'String';
    var COMMENT = 'Comment';

    /**
     * An exported enum describing the different kinds of tokens that the
     * lexer emits.
     */
    var TokenKind = exports.TokenKind = {
      SOF:       SOF,
      EOF:       EOF,
      BANG:      BANG,
      DOLLAR:    DOLLAR,
      PAREN_L:   PAREN_L,
      PAREN_R:   PAREN_R,
      SPREAD:    SPREAD,
      COLON:     COLON,
      EQUALS:    EQUALS,
      AT:        AT,
      BRACKET_L: BRACKET_L,
      BRACKET_R: BRACKET_R,
      BRACE_L:   BRACE_L,
      PIPE:      PIPE,
      BRACE_R:   BRACE_R,
      NAME:      NAME,
      INT:       INT,
      FLOAT:     FLOAT,
      STRING:    STRING,
      COMMENT:   COMMENT
    };

    /**
     * A helper function to describe a token as a string for debugging
     */
    function getTokenDesc(token) {
      var value = token.value;
      return value ? token.kind + ' "' + value + '"' : token.kind;
    }

    var charCodeAt = String.prototype.charCodeAt;
    var slice = String.prototype.slice;

    /**
     * Helper function for constructing the Token object.
     */
    function Tok(kind, start, end, line, column, prev, value) {
      this.kind = kind;
      this.start = start;
      this.end = end;
      this.line = line;
      this.column = column;
      this.value = value;
      this.prev = prev;
      this.next = null;
    }

// Print a simplified form when appearing in JSON/util.inspect.
    Tok.prototype.toJSON = Tok.prototype.inspect = function toJSON() {
      return {
        kind:   this.kind,
        value:  this.value,
        line:   this.line,
        column: this.column
      };
    };

    function printCharCode(code) {
      return (
        // NaN/undefined represents access beyond the end of the file.
        isNaN(code) ? EOF :
          // Trust JSON for ASCII.
          code < 0x007F ? JSON.stringify(String.fromCharCode(code)) :
            // Otherwise print the escaped form.
            '"\\u' + ('00' + code.toString(16).toUpperCase()).slice(-4) + '"'
      );
    }

    /**
     * Gets the next token from the source starting at the given position.
     *
     * This skips over whitespace and comments until it finds the next lexable
     * token, then lexes punctuators immediately or calls the appropriate helper
     * function for more complicated tokens.
     */
    function readToken(lexer, prev) {
      var source = lexer.source;
      var body = source.body;
      var bodyLength = body.length;

      var position = positionAfterWhitespace(body, prev.end, lexer);
      var line = lexer.line;
      var col = 1 + position - lexer.lineStart;

      if (position >= bodyLength) {
        return new Tok(EOF, bodyLength, bodyLength, line, col, prev);
      }

      var code = charCodeAt.call(body, position);

      // SourceCharacter
      if (code < 0x0020 && code !== 0x0009 && code !== 0x000A && code !== 0x000D) {
        throw (0, _error.syntaxError)(source, position, 'Cannot contain the invalid character ' + printCharCode(code) + '.');
      }

      switch (code) {
        // !
        case 33:
          return new Tok(BANG, position, position + 1, line, col, prev);
        // #
        case 35:
          return readComment(source, position, line, col, prev);
        // $
        case 36:
          return new Tok(DOLLAR, position, position + 1, line, col, prev);
        // (
        case 40:
          return new Tok(PAREN_L, position, position + 1, line, col, prev);
        // )
        case 41:
          return new Tok(PAREN_R, position, position + 1, line, col, prev);
        // .
        case 46:
          if (charCodeAt.call(body, position + 1) === 46 && charCodeAt.call(body, position + 2) === 46) {
            return new Tok(SPREAD, position, position + 3, line, col, prev);
          }
          break;
        // :
        case 58:
          return new Tok(COLON, position, position + 1, line, col, prev);
        // =
        case 61:
          return new Tok(EQUALS, position, position + 1, line, col, prev);
        // @
        case 64:
          return new Tok(AT, position, position + 1, line, col, prev);
        // [
        case 91:
          return new Tok(BRACKET_L, position, position + 1, line, col, prev);
        // ]
        case 93:
          return new Tok(BRACKET_R, position, position + 1, line, col, prev);
        // {
        case 123:
          return new Tok(BRACE_L, position, position + 1, line, col, prev);
        // |
        case 124:
          return new Tok(PIPE, position, position + 1, line, col, prev);
        // }
        case 125:
          return new Tok(BRACE_R, position, position + 1, line, col, prev);
        // A-Z _ a-z
        case 65:
        case 66:
        case 67:
        case 68:
        case 69:
        case 70:
        case 71:
        case 72:
        case 73:
        case 74:
        case 75:
        case 76:
        case 77:
        case 78:
        case 79:
        case 80:
        case 81:
        case 82:
        case 83:
        case 84:
        case 85:
        case 86:
        case 87:
        case 88:
        case 89:
        case 90:
        case 95:
        case 97:
        case 98:
        case 99:
        case 100:
        case 101:
        case 102:
        case 103:
        case 104:
        case 105:
        case 106:
        case 107:
        case 108:
        case 109:
        case 110:
        case 111:
        case 112:
        case 113:
        case 114:
        case 115:
        case 116:
        case 117:
        case 118:
        case 119:
        case 120:
        case 121:
        case 122:
          return readName(source, position, line, col, prev);
        // - 0-9
        case 45:
        case 48:
        case 49:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
          return readNumber(source, position, code, line, col, prev);
        // "
        case 34:
          return readString(source, position, line, col, prev);
      }

      throw (0, _error.syntaxError)(source, position, unexpectedCharacterMessage(code));
    }

    /**
     * Report a message that an unexpected character was encountered.
     */
    function unexpectedCharacterMessage(code) {
      if (code === 39) {
        // '
        return 'Unexpected single quote character (\'), did you mean to use ' + 'a double quote (")?';
      }

      return 'Cannot parse the unexpected character ' + printCharCode(code) + '.';
    }

    /**
     * Reads from body starting at startPosition until it finds a non-whitespace
     * or commented character, then returns the position of that character for
     * lexing.
     */
    function positionAfterWhitespace(body, startPosition, lexer) {
      var bodyLength = body.length;
      var position = startPosition;
      while (position < bodyLength) {
        var code = charCodeAt.call(body, position);
        // tab | space | comma | BOM
        if (code === 9 || code === 32 || code === 44 || code === 0xFEFF) {
          ++position;
        } else if (code === 10) {
          // new line
          ++position;
          ++lexer.line;
          lexer.lineStart = position;
        } else if (code === 13) {
          // carriage return
          if (charCodeAt.call(body, position + 1) === 10) {
            position += 2;
          } else {
            ++position;
          }
          ++lexer.line;
          lexer.lineStart = position;
        } else {
          break;
        }
      }
      return position;
    }

    /**
     * Reads a comment token from the source file.
     *
     * #[\u0009\u0020-\uFFFF]*
     */
    function readComment(source, start, line, col, prev) {
      var body = source.body;
      var code = void 0;
      var position = start;

      do {
        code = charCodeAt.call(body, ++position);
      } while (code !== null && (
        // SourceCharacter but not LineTerminator
        code > 0x001F || code === 0x0009));

      return new Tok(COMMENT, start, position, line, col, prev, slice.call(body, start + 1, position));
    }

    /**
     * Reads a number token from the source file, either a float
     * or an int depending on whether a decimal point appears.
     *
     * Int:   -?(0|[1-9][0-9]*)
     * Float: -?(0|[1-9][0-9]*)(\.[0-9]+)?((E|e)(+|-)?[0-9]+)?
     */
    function readNumber(source, start, firstCode, line, col, prev) {
      var body = source.body;
      var code = firstCode;
      var position = start;
      var isFloat = false;

      if (code === 45) {
        // -
        code = charCodeAt.call(body, ++position);
      }

      if (code === 48) {
        // 0
        code = charCodeAt.call(body, ++position);
        if (code >= 48 && code <= 57) {
          throw (0, _error.syntaxError)(source, position, 'Invalid number, unexpected digit after 0: ' + printCharCode(code) + '.');
        }
      } else {
        position = readDigits(source, position, code);
        code = charCodeAt.call(body, position);
      }

      if (code === 46) {
        // .
        isFloat = true;

        code = charCodeAt.call(body, ++position);
        position = readDigits(source, position, code);
        code = charCodeAt.call(body, position);
      }

      if (code === 69 || code === 101) {
        // E e
        isFloat = true;

        code = charCodeAt.call(body, ++position);
        if (code === 43 || code === 45) {
          // + -
          code = charCodeAt.call(body, ++position);
        }
        position = readDigits(source, position, code);
      }

      return new Tok(isFloat ? FLOAT : INT, start, position, line, col, prev, slice.call(body, start, position));
    }

    /**
     * Returns the new position in the source after reading digits.
     */
    function readDigits(source, start, firstCode) {
      var body = source.body;
      var position = start;
      var code = firstCode;
      if (code >= 48 && code <= 57) {
        // 0 - 9
        do {
          code = charCodeAt.call(body, ++position);
        } while (code >= 48 && code <= 57); // 0 - 9
        return position;
      }
      throw (0, _error.syntaxError)(source, position, 'Invalid number, expected digit but got: ' + printCharCode(code) + '.');
    }

    /**
     * Reads a string token from the source file.
     *
     * "([^"\\\u000A\u000D]|(\\(u[0-9a-fA-F]{4}|["\\/bfnrt])))*"
     */
    function readString(source, start, line, col, prev) {
      var body = source.body;
      var position = start + 1;
      var chunkStart = position;
      var code = 0;
      var value = '';

      while (position < body.length && (code = charCodeAt.call(body, position)) !== null &&
      // not LineTerminator
      code !== 0x000A && code !== 0x000D &&
      // not Quote (")
      code !== 34) {
        // SourceCharacter
        if (code < 0x0020 && code !== 0x0009) {
          throw (0, _error.syntaxError)(source, position, 'Invalid character within String: ' + printCharCode(code) + '.');
        }

        ++position;
        if (code === 92) {
          // \
          value += slice.call(body, chunkStart, position - 1);
          code = charCodeAt.call(body, position);
          switch (code) {
            case 34:
              value += '"';
              break;
            case 47:
              value += '/';
              break;
            case 92:
              value += '\\';
              break;
            case 98:
              value += '\b';
              break;
            case 102:
              value += '\f';
              break;
            case 110:
              value += '\n';
              break;
            case 114:
              value += '\r';
              break;
            case 116:
              value += '\t';
              break;
            case 117:
              // u
              var charCode = uniCharCode(charCodeAt.call(body, position + 1), charCodeAt.call(body, position + 2), charCodeAt.call(body, position + 3), charCodeAt.call(body, position + 4));
              if (charCode < 0) {
                throw (0, _error.syntaxError)(source, position, 'Invalid character escape sequence: ' + ('\\u' + body.slice(position + 1, position + 5) + '.'));
              }
              value += String.fromCharCode(charCode);
              position += 4;
              break;
            default:
              throw (0, _error.syntaxError)(source, position, 'Invalid character escape sequence: \\' + String.fromCharCode(code) + '.');
          }
          ++position;
          chunkStart = position;
        }
      }

      if (code !== 34) {
        // quote (")
        throw (0, _error.syntaxError)(source, position, 'Unterminated string.');
      }

      value += slice.call(body, chunkStart, position);
      return new Tok(STRING, start, position + 1, line, col, prev, value);
    }

    /**
     * Converts four hexidecimal chars to the integer that the
     * string represents. For example, uniCharCode('0','0','0','f')
     * will return 15, and uniCharCode('0','0','f','f') returns 255.
     *
     * Returns a negative number on error, if a char was invalid.
     *
     * This is implemented by noting that char2hex() returns -1 on error,
     * which means the result of ORing the char2hex() will also be negative.
     */
    function uniCharCode(a, b, c, d) {
      return char2hex(a) << 12 | char2hex(b) << 8 | char2hex(c) << 4 | char2hex(d);
    }

    /**
     * Converts a hex character to its integer value.
     * '0' becomes 0, '9' becomes 9
     * 'A' becomes 10, 'F' becomes 15
     * 'a' becomes 10, 'f' becomes 15
     *
     * Returns -1 on error.
     */
    function char2hex(a) {
      return a >= 48 && a <= 57 ? a - 48 : // 0-9
        a >= 65 && a <= 70 ? a - 55 : // A-F
          a >= 97 && a <= 102 ? a - 87 : // a-f
            -1;
    }

    /**
     * Reads an alphanumeric + underscore name from the source.
     *
     * [_A-Za-z][_0-9A-Za-z]*
     */
    function readName(source, position, line, col, prev) {
      var body = source.body;
      var bodyLength = body.length;
      var end = position + 1;
      var code = 0;
      while (end !== bodyLength && (code = charCodeAt.call(body, end)) !== null && (code === 95 || // _
        code >= 48 && code <= 57 || // 0-9
        code >= 65 && code <= 90 || // A-Z
        code >= 97 && code <= 122 // a-z
      )) {
        ++end;
      }
      return new Tok(NAME, position, end, line, col, prev, slice.call(body, position, end));
    }

    /***/
  }),
  /* 25 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.getLocation = getLocation;

    /**
     * Takes a Source and a UTF-8 character offset, and returns the corresponding
     * line and column as a SourceLocation.
     */

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function getLocation(source, position) {
      var lineRegexp = /\r\n|[\n\r]/g;
      var line = 1;
      var column = position + 1;
      var match = void 0;
      while ((match = lineRegexp.exec(source.body)) && match.index < position) {
        line += 1;
        column = position + 1 - (match.index + match[ 0 ].length);
      }
      return { line: line, column: column };
    }

    /**
     * Represents a location in a Source.
     */

    /***/
  }),
  /* 26 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    /**
     * A representation of source input to GraphQL. The name is optional,
     * but is mostly useful for clients who store GraphQL documents in
     * source files; for example, if the GraphQL input is in a file Foo.graphql,
     * it might be useful for name to be "Foo.graphql".
     */
    var Source = exports.Source = function Source(body, name) {
      _classCallCheck(this, Source);

      this.body = body;
      this.name = name || 'GraphQL';
    };

    /***/
  }),
  /* 27 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.TypeInfo = undefined;

    var _kinds = __webpack_require__(2);

    var Kind = _interopRequireWildcard(_kinds);

    var _definition = __webpack_require__(1);

    var _introspection = __webpack_require__(11);

    var _typeFromAST = __webpack_require__(9);

    var _find = __webpack_require__(10);

    var _find2 = _interopRequireDefault(_find);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    function _interopRequireWildcard(obj) {
      if (obj && obj.__esModule) {
        return obj;
      } else {
        var newObj = {};
        if (obj != null) {
          for (var key in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[ key ] = obj[ key ];
          }
        }
        newObj.default = obj;
        return newObj;
      }
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    /**
     * TypeInfo is a utility class which, given a GraphQL schema, can keep track
     * of the current field and type definitions at any point in a GraphQL document
     * AST during a recursive descent by calling `enter(node)` and `leave(node)`.
     */
    var TypeInfo = exports.TypeInfo = function() {
      function TypeInfo(schema,
                        // NOTE: this experimental optional second parameter is only needed in order
                        // to support non-spec-compliant codebases. You should never need to use it.
                        getFieldDefFn) {
        _classCallCheck(this, TypeInfo);

        this._schema = schema;
        this._typeStack = [];
        this._parentTypeStack = [];
        this._inputTypeStack = [];
        this._fieldDefStack = [];
        this._directive = null;
        this._argument = null;
        this._enumValue = null;
        this._getFieldDef = getFieldDefFn || getFieldDef;
      }

      TypeInfo.prototype.getType = function getType() {
        if (this._typeStack.length > 0) {
          return this._typeStack[ this._typeStack.length - 1 ];
        }
      };

      TypeInfo.prototype.getParentType = function getParentType() {
        if (this._parentTypeStack.length > 0) {
          return this._parentTypeStack[ this._parentTypeStack.length - 1 ];
        }
      };

      TypeInfo.prototype.getInputType = function getInputType() {
        if (this._inputTypeStack.length > 0) {
          return this._inputTypeStack[ this._inputTypeStack.length - 1 ];
        }
      };

      TypeInfo.prototype.getFieldDef = function getFieldDef() {
        if (this._fieldDefStack.length > 0) {
          return this._fieldDefStack[ this._fieldDefStack.length - 1 ];
        }
      };

      TypeInfo.prototype.getDirective = function getDirective() {
        return this._directive;
      };

      TypeInfo.prototype.getArgument = function getArgument() {
        return this._argument;
      };

      TypeInfo.prototype.getEnumValue = function getEnumValue() {
        return this._enumValue;
      };

      // Flow does not yet handle this case.

      TypeInfo.prototype.enter = function enter(node /* ASTNode */) {
        var schema = this._schema;
        switch (node.kind) {
          case Kind.SELECTION_SET:
            var namedType = (0, _definition.getNamedType)(this.getType());
            var compositeType = void 0;
            if ((0, _definition.isCompositeType)(namedType)) {
              // isCompositeType is a type refining predicate, so this is safe.
              compositeType = namedType;
            }
            this._parentTypeStack.push(compositeType);
            break;
          case Kind.FIELD:
            var parentType = this.getParentType();
            var fieldDef = void 0;
            if (parentType) {
              fieldDef = this._getFieldDef(schema, parentType, node);
            }
            this._fieldDefStack.push(fieldDef);
            this._typeStack.push(fieldDef && fieldDef.type);
            break;
          case Kind.DIRECTIVE:
            this._directive = schema.getDirective(node.name.value);
            break;
          case Kind.OPERATION_DEFINITION:
            var type = void 0;
            if (node.operation === 'query') {
              type = schema.getQueryType();
            } else if (node.operation === 'mutation') {
              type = schema.getMutationType();
            } else if (node.operation === 'subscription') {
              type = schema.getSubscriptionType();
            }
            this._typeStack.push(type);
            break;
          case Kind.INLINE_FRAGMENT:
          case Kind.FRAGMENT_DEFINITION:
            var typeConditionAST = node.typeCondition;
            var outputType = typeConditionAST ? (0, _typeFromAST.typeFromAST)(schema, typeConditionAST) : this.getType();
            this._typeStack.push(outputType);
            break;
          case Kind.VARIABLE_DEFINITION:
            var inputType = (0, _typeFromAST.typeFromAST)(schema, node.type);
            this._inputTypeStack.push(inputType);
            break;
          case Kind.ARGUMENT:
            var argDef = void 0;
            var argType = void 0;
            var fieldOrDirective = this.getDirective() || this.getFieldDef();
            if (fieldOrDirective) {
              argDef = (0, _find2.default)(fieldOrDirective.args, function(arg) {
                return arg.name === node.name.value;
              });
              if (argDef) {
                argType = argDef.type;
              }
            }
            this._argument = argDef;
            this._inputTypeStack.push(argType);
            break;
          case Kind.LIST:
            var listType = (0, _definition.getNullableType)(this.getInputType());
            this._inputTypeStack.push(listType instanceof _definition.GraphQLList ? listType.ofType : undefined);
            break;
          case Kind.OBJECT_FIELD:
            var objectType = (0, _definition.getNamedType)(this.getInputType());
            var fieldType = void 0;
            if (objectType instanceof _definition.GraphQLInputObjectType) {
              var inputField = objectType.getFields()[ node.name.value ];
              fieldType = inputField ? inputField.type : undefined;
            }
            this._inputTypeStack.push(fieldType);
            break;
          case Kind.ENUM:
            var enumType = (0, _definition.getNamedType)(this.getInputType());
            var enumValue = void 0;
            if (enumType instanceof _definition.GraphQLEnumType) {
              enumValue = enumType.getValue(node.value);
            }
            this._enumValue = enumValue;
            break;
        }
      };

      TypeInfo.prototype.leave = function leave(node) {
        switch (node.kind) {
          case Kind.SELECTION_SET:
            this._parentTypeStack.pop();
            break;
          case Kind.FIELD:
            this._fieldDefStack.pop();
            this._typeStack.pop();
            break;
          case Kind.DIRECTIVE:
            this._directive = null;
            break;
          case Kind.OPERATION_DEFINITION:
          case Kind.INLINE_FRAGMENT:
          case Kind.FRAGMENT_DEFINITION:
            this._typeStack.pop();
            break;
          case Kind.VARIABLE_DEFINITION:
            this._inputTypeStack.pop();
            break;
          case Kind.ARGUMENT:
            this._argument = null;
            this._inputTypeStack.pop();
            break;
          case Kind.LIST:
          case Kind.OBJECT_FIELD:
            this._inputTypeStack.pop();
            break;
          case Kind.ENUM:
            this._enumValue = null;
            break;
        }
      };

      return TypeInfo;
    }();

    /**
     * Not exactly the same as the executor's definition of getFieldDef, in this
     * statically evaluated environment we do not always have an Object type,
     * and need to handle Interface and Union types.
     */


    function getFieldDef(schema, parentType, fieldNode) {
      var name = fieldNode.name.value;
      if (name === _introspection.SchemaMetaFieldDef.name && schema.getQueryType() === parentType) {
        return _introspection.SchemaMetaFieldDef;
      }
      if (name === _introspection.TypeMetaFieldDef.name && schema.getQueryType() === parentType) {
        return _introspection.TypeMetaFieldDef;
      }
      if (name === _introspection.TypeNameMetaFieldDef.name && (parentType instanceof _definition.GraphQLObjectType || parentType instanceof _definition.GraphQLInterfaceType || parentType instanceof _definition.GraphQLUnionType)) {
        return _introspection.TypeNameMetaFieldDef;
      }
      if (parentType instanceof _definition.GraphQLObjectType || parentType instanceof _definition.GraphQLInterfaceType) {
        return parentType.getFields()[ name ];
      }
    }

    /***/
  }),
  /* 28 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.assertValidName = assertValidName;

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    var NAME_RX = /^[_a-zA-Z][_a-zA-Z0-9]*$/;

// Ensures console warnings are only issued once.
    var hasWarnedAboutDunder = false;

    /**
     * Upholds the spec rules about naming.
     */
    function assertValidName(name, isIntrospection) {
      if (!name || typeof name !== 'string') {
        throw new Error('Must be named. Unexpected name: ' + name + '.');
      }
      if (!isIntrospection && name.slice(0, 2) === '__' && !hasWarnedAboutDunder) {
        hasWarnedAboutDunder = true;
        /* eslint-disable no-console */
        if (console && console.error) {
          var error = new Error('Name "' + name + '" must not begin with "__", which is reserved by ' + 'GraphQL introspection.');
          console.error(error.stack || String(error));
        }
        /* eslint-enable no-console */
      }
      if (!NAME_RX.test(name)) {
        throw new Error('Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but "' + name + '" does not.');
      }
    }

    /***/
  }),
  /* 29 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.astFromValue = astFromValue;

    var _iterall = __webpack_require__(20);

    var _invariant = __webpack_require__(3);

    var _invariant2 = _interopRequireDefault(_invariant);

    var _isNullish = __webpack_require__(6);

    var _isNullish2 = _interopRequireDefault(_isNullish);

    var _isInvalid = __webpack_require__(14);

    var _isInvalid2 = _interopRequireDefault(_isInvalid);

    var _kinds = __webpack_require__(2);

    var _definition = __webpack_require__(1);

    var _scalars = __webpack_require__(7);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    /**
     * Produces a GraphQL Value AST given a JavaScript value.
     *
     * A GraphQL type must be provided, which will be used to interpret different
     * JavaScript values.
     *
     * | JSON Value    | GraphQL Value        |
     * | ------------- | -------------------- |
     * | Object        | Input Object         |
     * | Array         | List                 |
     * | Boolean       | Boolean              |
     * | String        | String / Enum Value  |
     * | Number        | Int / Float          |
     * | Mixed         | Enum Value           |
     * | null          | NullValue            |
     *
     */
    function astFromValue(value, type) {
      // Ensure flow knows that we treat function params as const.
      var _value = value;

      if (type instanceof _definition.GraphQLNonNull) {
        var astValue = astFromValue(_value, type.ofType);
        if (astValue && astValue.kind === _kinds.NULL) {
          return null;
        }
        return astValue;
      }

      // only explicit null, not undefined, NaN
      if (_value === null) {
        return { kind: _kinds.NULL };
      }

      // undefined, NaN
      if ((0, _isInvalid2.default)(_value)) {
        return null;
      }

      // Convert JavaScript array to GraphQL list. If the GraphQLType is a list, but
      // the value is not an array, convert the value using the list's item type.
      if (type instanceof _definition.GraphQLList) {
        var _ret = function() {
          var itemType = type.ofType;
          if ((0, _iterall.isCollection)(_value)) {
            var _ret2 = function() {
              var valuesNodes = [];
              (0, _iterall.forEach)(_value, function(item) {
                var itemNode = astFromValue(item, itemType);
                if (itemNode) {
                  valuesNodes.push(itemNode);
                }
              });
              return {
                v: {
                  v: { kind: _kinds.LIST, values: valuesNodes }
                }
              };
            }();

            if (typeof _ret2 === "object") return _ret2.v;
          }
          return {
            v: astFromValue(_value, itemType)
          };
        }();

        if (typeof _ret === "object") return _ret.v;
      }

      // Populate the fields of the input object by creating ASTs from each value
      // in the JavaScript object according to the fields in the input type.
      if (type instanceof _definition.GraphQLInputObjectType) {
        var _ret3 = function() {
          if (_value === null || typeof _value !== 'object') {
            return {
              v: null
            };
          }
          var fields = type.getFields();
          var fieldNodes = [];
          Object.keys(fields).forEach(function(fieldName) {
            var fieldType = fields[ fieldName ].type;
            var fieldValue = astFromValue(_value[ fieldName ], fieldType);
            if (fieldValue) {
              fieldNodes.push({
                kind:  _kinds.OBJECT_FIELD,
                name:  { kind: _kinds.NAME, value: fieldName },
                value: fieldValue
              });
            }
          });
          return {
            v: { kind: _kinds.OBJECT, fields: fieldNodes }
          };
        }();

        if (typeof _ret3 === "object") return _ret3.v;
      }

      (0, _invariant2.default)(type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType, 'Must provide Input Type, cannot use: ' + String(type));

      // Since value is an internally represented value, it must be serialized
      // to an externally represented value before converting into an AST.
      var serialized = type.serialize(_value);
      if ((0, _isNullish2.default)(serialized)) {
        return null;
      }

      // Others serialize based on their corresponding JavaScript scalar types.
      if (typeof serialized === 'boolean') {
        return { kind: _kinds.BOOLEAN, value: serialized };
      }

      // JavaScript numbers can be Int or Float values.
      if (typeof serialized === 'number') {
        var stringNum = String(serialized);
        return (/^[0-9]+$/.test(stringNum) ? { kind: _kinds.INT, value: stringNum } : {
            kind:  _kinds.FLOAT,
            value: stringNum
          }
        );
      }

      if (typeof serialized === 'string') {
        // Enum types use Enum literals.
        if (type instanceof _definition.GraphQLEnumType) {
          return { kind: _kinds.ENUM, value: serialized };
        }

        // ID types can use Int literals.
        if (type === _scalars.GraphQLID && /^[0-9]+$/.test(serialized)) {
          return { kind: _kinds.INT, value: serialized };
        }

        // Use JSON stringify, which uses the same string encoding as GraphQL,
        // then remove the quotes.
        return {
          kind:  _kinds.STRING,
          value: JSON.stringify(serialized).slice(1, -1)
        };
      }

      throw new TypeError('Cannot convert value to AST: ' + String(serialized));
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    /***/
  }),
  /* 30 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.defaultFieldResolver = undefined;
    exports.execute = execute;
    exports.responsePathAsArray = responsePathAsArray;

    var _iterall = __webpack_require__(20);

    var _error = __webpack_require__(0);

    var _find = __webpack_require__(10);

    var _find2 = _interopRequireDefault(_find);

    var _invariant = __webpack_require__(3);

    var _invariant2 = _interopRequireDefault(_invariant);

    var _isNullish = __webpack_require__(6);

    var _isNullish2 = _interopRequireDefault(_isNullish);

    var _typeFromAST = __webpack_require__(9);

    var _kinds = __webpack_require__(2);

    var Kind = _interopRequireWildcard(_kinds);

    var _values = __webpack_require__(31);

    var _definition = __webpack_require__(1);

    var _schema = __webpack_require__(8);

    var _introspection = __webpack_require__(11);

    var _directives = __webpack_require__(5);

    function _interopRequireWildcard(obj) {
      if (obj && obj.__esModule) {
        return obj;
      } else {
        var newObj = {};
        if (obj != null) {
          for (var key in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[ key ] = obj[ key ];
          }
        }
        newObj.default = obj;
        return newObj;
      }
    }

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    /**
     * Implements the "Evaluating requests" section of the GraphQL specification.
     *
     * Returns a Promise that will eventually be resolved and never rejected.
     *
     * If the arguments to this function do not result in a legal execution context,
     * a GraphQLError will be thrown immediately explaining the invalid input.
     */

    /**
     * Terminology
     *
     * "Definitions" are the generic name for top-level statements in the document.
     * Examples of this include:
     * 1) Operations (such as a query)
     * 2) Fragments
     *
     * "Operations" are a generic name for requests in the document.
     * Examples of this include:
     * 1) query,
     * 2) mutation
     *
     * "Selections" are the definitions that can appear legally and at
     * single level of the query. These include:
     * 1) field references e.g "a"
     * 2) fragment "spreads" e.g. "...c"
     * 3) inline fragment "spreads" e.g. "...on Type { a }"
     */

    /**
     * Data that must be available at all points during query execution.
     *
     * Namely, schema of the type system that is currently executing,
     * and the fragments defined in the query document
     */

    /**
     * The result of GraphQL execution.
     *
     *   - `data` is the result of a successful execution of the query.
     *   - `errors` is included when any errors occurred as a non-empty array.
     */

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function execute(schema, document, rootValue, contextValue, variableValues, operationName) {
      (0, _invariant2.default)(schema, 'Must provide schema');
      (0, _invariant2.default)(document, 'Must provide document');
      (0, _invariant2.default)(schema instanceof _schema.GraphQLSchema, 'Schema must be an instance of GraphQLSchema. Also ensure that there are ' + 'not multiple versions of GraphQL installed in your node_modules directory.');

      // Variables, if provided, must be an object.
      (0, _invariant2.default)(!variableValues || typeof variableValues === 'object', 'Variables must be provided as an Object where each property is a ' + 'variable value. Perhaps look to see if an unparsed JSON string ' + 'was provided.');

      // If a valid context cannot be created due to incorrect arguments,
      // this will throw an error.
      var context = buildExecutionContext(schema, document, rootValue, contextValue, variableValues, operationName);

      // Return a Promise that will eventually resolve to the data described by
      // The "Response" section of the GraphQL specification.
      //
      // If errors are encountered while executing a GraphQL field, only that
      // field and its descendants will be omitted, and sibling fields will still
      // be executed. An execution which encounters errors will still result in a
      // resolved Promise.
      return new Promise(function(resolve) {
        resolve(executeOperation(context, context.operation, rootValue));
      }).then(undefined, function(error) {
        // Errors from sub-fields of a NonNull type may propagate to the top level,
        // at which point we still log the error and null the parent field, which
        // in this case is the entire response.
        context.errors.push(error);
        return null;
      }).then(function(data) {
        if (!context.errors.length) {
          return { data: data };
        }
        return { data: data, errors: context.errors };
      });
    }

    /**
     * Given a ResponsePath (found in the `path` entry in the information provided
     * as the last argument to a field resolver), return an Array of the path keys.
     */
    function responsePathAsArray(path) {
      var flattened = [];
      var curr = path;
      while (curr) {
        flattened.push(curr.key);
        curr = curr.prev;
      }
      return flattened.reverse();
    }

    function addPath(prev, key) {
      return { prev: prev, key: key };
    }

    /**
     * Constructs a ExecutionContext object from the arguments passed to
     * execute, which we will pass throughout the other execution methods.
     *
     * Throws a GraphQLError if a valid execution context cannot be created.
     */
    function buildExecutionContext(schema, document, rootValue, contextValue, rawVariableValues, operationName) {
      var errors = [];
      var operation = void 0;
      var fragments = Object.create(null);
      document.definitions.forEach(function(definition) {
        switch (definition.kind) {
          case Kind.OPERATION_DEFINITION:
            if (!operationName && operation) {
              throw new _error.GraphQLError('Must provide operation name if query contains multiple operations.');
            }
            if (!operationName || definition.name && definition.name.value === operationName) {
              operation = definition;
            }
            break;
          case Kind.FRAGMENT_DEFINITION:
            fragments[ definition.name.value ] = definition;
            break;
          default:
            throw new _error.GraphQLError('GraphQL cannot execute a request containing a ' + definition.kind + '.', [ definition ]);
        }
      });
      if (!operation) {
        if (operationName) {
          throw new _error.GraphQLError('Unknown operation named "' + operationName + '".');
        } else {
          throw new _error.GraphQLError('Must provide an operation.');
        }
      }
      var variableValues = (0, _values.getVariableValues)(schema, operation.variableDefinitions || [], rawVariableValues || {});

      return {
        schema:         schema,
        fragments:      fragments,
        rootValue:      rootValue,
        contextValue:   contextValue,
        operation:      operation,
        variableValues: variableValues,
        errors:         errors
      };
    }

    /**
     * Implements the "Evaluating operations" section of the spec.
     */
    function executeOperation(exeContext, operation, rootValue) {
      var type = getOperationRootType(exeContext.schema, operation);
      var fields = collectFields(exeContext, type, operation.selectionSet, Object.create(null), Object.create(null));

      var path = undefined;

      if (operation.operation === 'mutation') {
        return executeFieldsSerially(exeContext, type, rootValue, path, fields);
      }
      return executeFields(exeContext, type, rootValue, path, fields);
    }

    /**
     * Extracts the root type of the operation from the schema.
     */
    function getOperationRootType(schema, operation) {
      switch (operation.operation) {
        case 'query':
          return schema.getQueryType();
        case 'mutation':
          var mutationType = schema.getMutationType();
          if (!mutationType) {
            throw new _error.GraphQLError('Schema is not configured for mutations', [ operation ]);
          }
          return mutationType;
        case 'subscription':
          var subscriptionType = schema.getSubscriptionType();
          if (!subscriptionType) {
            throw new _error.GraphQLError('Schema is not configured for subscriptions', [ operation ]);
          }
          return subscriptionType;
        default:
          throw new _error.GraphQLError('Can only execute queries, mutations and subscriptions', [ operation ]);
      }
    }

    /**
     * Implements the "Evaluating selection sets" section of the spec
     * for "write" mode.
     */
    function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields) {
      return Object.keys(fields).reduce(function(prevPromise, responseName) {
        return prevPromise.then(function(results) {
          var fieldNodes = fields[ responseName ];
          var fieldPath = addPath(path, responseName);
          var result = resolveField(exeContext, parentType, sourceValue, fieldNodes, fieldPath);
          if (result === undefined) {
            return results;
          }
          if (isThenable(result)) {
            return result.then(function(resolvedResult) {
              results[ responseName ] = resolvedResult;
              return results;
            });
          }
          results[ responseName ] = result;
          return results;
        });
      }, Promise.resolve({}));
    }

    /**
     * Implements the "Evaluating selection sets" section of the spec
     * for "read" mode.
     */
    function executeFields(exeContext, parentType, sourceValue, path, fields) {
      var containsPromise = false;

      var finalResults = Object.keys(fields).reduce(function(results, responseName) {
        var fieldNodes = fields[ responseName ];
        var fieldPath = addPath(path, responseName);
        var result = resolveField(exeContext, parentType, sourceValue, fieldNodes, fieldPath);
        if (result === undefined) {
          return results;
        }
        results[ responseName ] = result;
        if (isThenable(result)) {
          containsPromise = true;
        }
        return results;
      }, Object.create(null));

      // If there are no promises, we can just return the object
      if (!containsPromise) {
        return finalResults;
      }

      // Otherwise, results is a map from field name to the result
      // of resolving that field, which is possibly a promise. Return
      // a promise that will return this same map, but with any
      // promises replaced with the values they resolved to.
      return promiseForObject(finalResults);
    }

    /**
     * Given a selectionSet, adds all of the fields in that selection to
     * the passed in map of fields, and returns it at the end.
     *
     * CollectFields requires the "runtime type" of an object. For a field which
     * returns and Interface or Union type, the "runtime type" will be the actual
     * Object type returned by that field.
     */
    function collectFields(exeContext, runtimeType, selectionSet, fields, visitedFragmentNames) {
      for (var i = 0; i < selectionSet.selections.length; i++) {
        var selection = selectionSet.selections[ i ];
        switch (selection.kind) {
          case Kind.FIELD:
            if (!shouldIncludeNode(exeContext, selection.directives)) {
              continue;
            }
            var _name = getFieldEntryKey(selection);
            if (!fields[ _name ]) {
              fields[ _name ] = [];
            }
            fields[ _name ].push(selection);
            break;
          case Kind.INLINE_FRAGMENT:
            if (!shouldIncludeNode(exeContext, selection.directives) || !doesFragmentConditionMatch(exeContext, selection, runtimeType)) {
              continue;
            }
            collectFields(exeContext, runtimeType, selection.selectionSet, fields, visitedFragmentNames);
            break;
          case Kind.FRAGMENT_SPREAD:
            var fragName = selection.name.value;
            if (visitedFragmentNames[ fragName ] || !shouldIncludeNode(exeContext, selection.directives)) {
              continue;
            }
            visitedFragmentNames[ fragName ] = true;
            var fragment = exeContext.fragments[ fragName ];
            if (!fragment || !doesFragmentConditionMatch(exeContext, fragment, runtimeType)) {
              continue;
            }
            collectFields(exeContext, runtimeType, fragment.selectionSet, fields, visitedFragmentNames);
            break;
        }
      }
      return fields;
    }

    /**
     * Determines if a field should be included based on the @include and @skip
     * directives, where @skip has higher precidence than @include.
     */
    function shouldIncludeNode(exeContext, directives) {
      var skipNode = directives && (0, _find2.default)(directives, function(directive) {
        return directive.name.value === _directives.GraphQLSkipDirective.name;
      });
      if (skipNode) {
        var _getArgumentValues = (0, _values.getArgumentValues)(_directives.GraphQLSkipDirective, skipNode, exeContext.variableValues),
          skipIf = _getArgumentValues.if;

        if (skipIf === true) {
          return false;
        }
      }

      var includeNode = directives && (0, _find2.default)(directives, function(directive) {
        return directive.name.value === _directives.GraphQLIncludeDirective.name;
      });
      if (includeNode) {
        var _getArgumentValues2 = (0, _values.getArgumentValues)(_directives.GraphQLIncludeDirective, includeNode, exeContext.variableValues),
          includeIf = _getArgumentValues2.if;

        if (includeIf === false) {
          return false;
        }
      }

      return true;
    }

    /**
     * Determines if a fragment is applicable to the given type.
     */
    function doesFragmentConditionMatch(exeContext, fragment, type) {
      var typeConditionNode = fragment.typeCondition;
      if (!typeConditionNode) {
        return true;
      }
      var conditionalType = (0, _typeFromAST.typeFromAST)(exeContext.schema, typeConditionNode);
      if (conditionalType === type) {
        return true;
      }
      if ((0, _definition.isAbstractType)(conditionalType)) {
        var abstractType = conditionalType;
        return exeContext.schema.isPossibleType(abstractType, type);
      }
      return false;
    }

    /**
     * This function transforms a JS object `{[key: string]: Promise<T>}` into
     * a `Promise<{[key: string]: T}>`
     *
     * This is akin to bluebird's `Promise.props`, but implemented only using
     * `Promise.all` so it will work with any implementation of ES6 promises.
     */
    function promiseForObject(object) {
      var keys = Object.keys(object);
      var valuesAndPromises = keys.map(function(name) {
        return object[ name ];
      });
      return Promise.all(valuesAndPromises).then(function(values) {
        return values.reduce(function(resolvedObject, value, i) {
          resolvedObject[ keys[ i ] ] = value;
          return resolvedObject;
        }, Object.create(null));
      });
    }

    /**
     * Implements the logic to compute the key of a given field's entry
     */
    function getFieldEntryKey(node) {
      return node.alias ? node.alias.value : node.name.value;
    }

    /**
     * Resolves the field on the given source object. In particular, this
     * figures out the value that the field returns by calling its resolve function,
     * then calls completeValue to complete promises, serialize scalars, or execute
     * the sub-selection-set for objects.
     */
    function resolveField(exeContext, parentType, source, fieldNodes, path) {
      var fieldNode = fieldNodes[ 0 ];
      var fieldName = fieldNode.name.value;

      var fieldDef = getFieldDef(exeContext.schema, parentType, fieldName);
      if (!fieldDef) {
        return;
      }

      var returnType = fieldDef.type;
      var resolveFn = fieldDef.resolve || defaultFieldResolver;

      // The resolve function's optional third argument is a context value that
      // is provided to every resolve function within an execution. It is commonly
      // used to represent an authenticated user, or request-specific caches.
      var context = exeContext.contextValue;

      // The resolve function's optional fourth argument is a collection of
      // information about the current execution state.
      var info = {
        fieldName:      fieldName,
        fieldNodes:     fieldNodes,
        returnType:     returnType,
        parentType:     parentType,
        path:           path,
        schema:         exeContext.schema,
        fragments:      exeContext.fragments,
        rootValue:      exeContext.rootValue,
        operation:      exeContext.operation,
        variableValues: exeContext.variableValues
      };

      // Get the resolve function, regardless of if its result is normal
      // or abrupt (error).
      var result = resolveOrError(exeContext, fieldDef, fieldNode, resolveFn, source, context, info);

      return completeValueCatchingError(exeContext, returnType, fieldNodes, info, path, result);
    }

// Isolates the "ReturnOrAbrupt" behavior to not de-opt the `resolveField`
// function. Returns the result of resolveFn or the abrupt-return Error object.
    function resolveOrError(exeContext, fieldDef, fieldNode, resolveFn, source, context, info) {
      try {
        // Build a JS object of arguments from the field.arguments AST, using the
        // variables scope to fulfill any variable references.
        // TODO: find a way to memoize, in case this field is within a List type.
        var args = (0, _values.getArgumentValues)(fieldDef, fieldNode, exeContext.variableValues);

        return resolveFn(source, args, context, info);
      } catch (error) {
        // Sometimes a non-error is thrown, wrap it as an Error for a
        // consistent interface.
        return error instanceof Error ? error : new Error(error);
      }
    }

// This is a small wrapper around completeValue which detects and logs errors
// in the execution context.
    function completeValueCatchingError(exeContext, returnType, fieldNodes, info, path, result) {
      // If the field type is non-nullable, then it is resolved without any
      // protection from errors, however it still properly locates the error.
      if (returnType instanceof _definition.GraphQLNonNull) {
        return completeValueWithLocatedError(exeContext, returnType, fieldNodes, info, path, result);
      }

      // Otherwise, error protection is applied, logging the error and resolving
      // a null value for this field if one is encountered.
      try {
        var completed = completeValueWithLocatedError(exeContext, returnType, fieldNodes, info, path, result);
        if (isThenable(completed)) {
          // If `completeValueWithLocatedError` returned a rejected promise, log
          // the rejection error and resolve to null.
          // Note: we don't rely on a `catch` method, but we do expect "thenable"
          // to take a second callback for the error case.
          return completed.then(undefined, function(error) {
            exeContext.errors.push(error);
            return Promise.resolve(null);
          });
        }
        return completed;
      } catch (error) {
        // If `completeValueWithLocatedError` returned abruptly (threw an error),
        // log the error and return null.
        exeContext.errors.push(error);
        return null;
      }
    }

// This is a small wrapper around completeValue which annotates errors with
// location information.
    function completeValueWithLocatedError(exeContext, returnType, fieldNodes, info, path, result) {
      try {
        var completed = completeValue(exeContext, returnType, fieldNodes, info, path, result);
        if (isThenable(completed)) {
          return completed.then(undefined, function(error) {
            return Promise.reject((0, _error.locatedError)(error, fieldNodes, responsePathAsArray(path)));
          });
        }
        return completed;
      } catch (error) {
        throw (0, _error.locatedError)(error, fieldNodes, responsePathAsArray(path));
      }
    }

    /**
     * Implements the instructions for completeValue as defined in the
     * "Field entries" section of the spec.
     *
     * If the field type is Non-Null, then this recursively completes the value
     * for the inner type. It throws a field error if that completion returns null,
     * as per the "Nullability" section of the spec.
     *
     * If the field type is a List, then this recursively completes the value
     * for the inner type on each item in the list.
     *
     * If the field type is a Scalar or Enum, ensures the completed value is a legal
     * value of the type by calling the `serialize` method of GraphQL type
     * definition.
     *
     * If the field is an abstract type, determine the runtime type of the value
     * and then complete based on that type
     *
     * Otherwise, the field type expects a sub-selection set, and will complete the
     * value by evaluating all sub-selections.
     */
    function completeValue(exeContext, returnType, fieldNodes, info, path, result) {
      // If result is a Promise, apply-lift over completeValue.
      if (isThenable(result)) {
        return result.then(function(resolved) {
          return completeValue(exeContext, returnType, fieldNodes, info, path, resolved);
        });
      }

      // If result is an Error, throw a located error.
      if (result instanceof Error) {
        throw result;
      }

      // If field type is NonNull, complete for inner type, and throw field error
      // if result is null.
      if (returnType instanceof _definition.GraphQLNonNull) {
        var completed = completeValue(exeContext, returnType.ofType, fieldNodes, info, path, result);
        if (completed === null) {
          throw new Error('Cannot return null for non-nullable field ' + info.parentType.name + '.' + info.fieldName + '.');
        }
        return completed;
      }

      // If result value is null-ish (null, undefined, or NaN) then return null.
      if ((0, _isNullish2.default)(result)) {
        return null;
      }

      // If field type is List, complete each item in the list with the inner type
      if (returnType instanceof _definition.GraphQLList) {
        return completeListValue(exeContext, returnType, fieldNodes, info, path, result);
      }

      // If field type is a leaf type, Scalar or Enum, serialize to a valid value,
      // returning null if serialization is not possible.
      if (returnType instanceof _definition.GraphQLScalarType || returnType instanceof _definition.GraphQLEnumType) {
        return completeLeafValue(returnType, result);
      }

      // If field type is an abstract type, Interface or Union, determine the
      // runtime Object type and complete for that type.
      if (returnType instanceof _definition.GraphQLInterfaceType || returnType instanceof _definition.GraphQLUnionType) {
        return completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result);
      }

      // If field type is Object, execute and complete all sub-selections.
      if (returnType instanceof _definition.GraphQLObjectType) {
        return completeObjectValue(exeContext, returnType, fieldNodes, info, path, result);
      }

      // Not reachable. All possible output types have been considered.
      throw new Error('Cannot complete value of unexpected type "' + String(returnType) + '".');
    }

    /**
     * Complete a list value by completing each item in the list with the
     * inner type
     */
    function completeListValue(exeContext, returnType, fieldNodes, info, path, result) {
      (0, _invariant2.default)((0, _iterall.isCollection)(result), 'Expected Iterable, but did not find one for field ' + info.parentType.name + '.' + info.fieldName + '.');

      // This is specified as a simple map, however we're optimizing the path
      // where the list contains no Promises by avoiding creating another Promise.
      var itemType = returnType.ofType;
      var containsPromise = false;
      var completedResults = [];
      (0, _iterall.forEach)(result, function(item, index) {
        // No need to modify the info object containing the path,
        // since from here on it is not ever accessed by resolver functions.
        var fieldPath = addPath(path, index);
        var completedItem = completeValueCatchingError(exeContext, itemType, fieldNodes, info, fieldPath, item);

        if (!containsPromise && isThenable(completedItem)) {
          containsPromise = true;
        }
        completedResults.push(completedItem);
      });

      return containsPromise ? Promise.all(completedResults) : completedResults;
    }

    /**
     * Complete a Scalar or Enum by serializing to a valid value, returning
     * null if serialization is not possible.
     */
    function completeLeafValue(returnType, result) {
      (0, _invariant2.default)(returnType.serialize, 'Missing serialize method on type');
      var serializedResult = returnType.serialize(result);
      if ((0, _isNullish2.default)(serializedResult)) {
        throw new Error('Expected a value of type "' + String(returnType) + '" but ' + ('received: ' + String(result)));
      }
      return serializedResult;
    }

    /**
     * Complete a value of an abstract type by determining the runtime object type
     * of that value, then complete the value for that type.
     */
    function completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result) {
      var runtimeType = returnType.resolveType ? returnType.resolveType(result, exeContext.contextValue, info) : defaultResolveTypeFn(result, exeContext.contextValue, info, returnType);

      if (isThenable(runtimeType)) {
        // Cast to Promise
        var runtimeTypePromise = runtimeType;
        return runtimeTypePromise.then(function(resolvedRuntimeType) {
          return completeObjectValue(exeContext, ensureValidRuntimeType(resolvedRuntimeType, exeContext, returnType, fieldNodes, info, result), fieldNodes, info, path, result);
        });
      }

      return completeObjectValue(exeContext, ensureValidRuntimeType(runtimeType, exeContext, returnType, fieldNodes, info, result), fieldNodes, info, path, result);
    }

    function ensureValidRuntimeType(runtimeTypeOrName, exeContext, returnType, fieldNodes, info, result) {
      var runtimeType = typeof runtimeTypeOrName === 'string' ? exeContext.schema.getType(runtimeTypeOrName) : runtimeTypeOrName;

      if (!(runtimeType instanceof _definition.GraphQLObjectType)) {
        throw new _error.GraphQLError('Abstract type ' + returnType.name + ' must resolve to an Object type at ' + ('runtime for field ' + info.parentType.name + '.' + info.fieldName + ' with ') + ('value "' + String(result) + '", received "' + String(runtimeType) + '".'), fieldNodes);
      }

      if (!exeContext.schema.isPossibleType(returnType, runtimeType)) {
        throw new _error.GraphQLError('Runtime Object type "' + runtimeType.name + '" is not a possible type ' + ('for "' + returnType.name + '".'), fieldNodes);
      }

      return runtimeType;
    }

    /**
     * Complete an Object value by executing all sub-selections.
     */
    function completeObjectValue(exeContext, returnType, fieldNodes, info, path, result) {
      // If there is an isTypeOf predicate function, call it with the
      // current result. If isTypeOf returns false, then raise an error rather
      // than continuing execution.
      if (returnType.isTypeOf) {
        var isTypeOf = returnType.isTypeOf(result, exeContext.contextValue, info);

        if (isThenable(isTypeOf)) {
          return isTypeOf.then(function(isTypeOfResult) {
            if (!isTypeOfResult) {
              throw invalidReturnTypeError(returnType, result, fieldNodes);
            }
            return collectAndExecuteSubfields(exeContext, returnType, fieldNodes, info, path, result);
          });
        }

        if (!isTypeOf) {
          throw invalidReturnTypeError(returnType, result, fieldNodes);
        }
      }

      return collectAndExecuteSubfields(exeContext, returnType, fieldNodes, info, path, result);
    }

    function invalidReturnTypeError(returnType, result, fieldNodes) {
      return new _error.GraphQLError('Expected value of type "' + returnType.name + '" but got: ' + String(result) + '.', fieldNodes);
    }

    function collectAndExecuteSubfields(exeContext, returnType, fieldNodes, info, path, result) {
      // Collect sub-fields to execute to complete this value.
      var subFieldNodes = Object.create(null);
      var visitedFragmentNames = Object.create(null);
      for (var i = 0; i < fieldNodes.length; i++) {
        var selectionSet = fieldNodes[ i ].selectionSet;
        if (selectionSet) {
          subFieldNodes = collectFields(exeContext, returnType, selectionSet, subFieldNodes, visitedFragmentNames);
        }
      }

      return executeFields(exeContext, returnType, result, path, subFieldNodes);
    }

    /**
     * If a resolveType function is not given, then a default resolve behavior is
     * used which tests each possible type for the abstract type by calling
     * isTypeOf for the object being coerced, returning the first type that matches.
     */
    function defaultResolveTypeFn(value, context, info, abstractType) {
      var possibleTypes = info.schema.getPossibleTypes(abstractType);
      var promisedIsTypeOfResults = [];

      for (var i = 0; i < possibleTypes.length; i++) {
        var type = possibleTypes[ i ];

        if (type.isTypeOf) {
          var isTypeOfResult = type.isTypeOf(value, context, info);

          if (isThenable(isTypeOfResult)) {
            promisedIsTypeOfResults[ i ] = isTypeOfResult;
          } else if (isTypeOfResult) {
            return type;
          }
        }
      }

      if (promisedIsTypeOfResults.length) {
        return Promise.all(promisedIsTypeOfResults).then(function(isTypeOfResults) {
          for (var _i = 0; _i < isTypeOfResults.length; _i++) {
            if (isTypeOfResults[ _i ]) {
              return possibleTypes[ _i ];
            }
          }
        });
      }
    }

    /**
     * If a resolve function is not given, then a default resolve behavior is used
     * which takes the property of the source object of the same name as the field
     * and returns it as the result, or if it's a function, returns the result
     * of calling that function while passing along args and context.
     */
    var defaultFieldResolver = exports.defaultFieldResolver = function defaultFieldResolver(source, args, context, info) {
      // ensure source is a value for which property access is acceptable.
      if (typeof source === 'object' || typeof source === 'function') {
        var property = source[ info.fieldName ];
        if (typeof property === 'function') {
          return source[ info.fieldName ](args, context, info);
        }
        return property;
      }
    };

    /**
     * Checks to see if this object acts like a Promise, i.e. has a "then"
     * function.
     */
    function isThenable(value) {
      return typeof value === 'object' && value !== null && typeof value.then === 'function';
    }

    /**
     * This method looks up the field on the given type defintion.
     * It has special casing for the two introspection fields, __schema
     * and __typename. __typename is special because it can always be
     * queried as a field, even in situations where no other fields
     * are allowed, like on a Union. __schema could get automatically
     * added to the query type, but that would require mutating type
     * definitions, which would cause issues.
     */
    function getFieldDef(schema, parentType, fieldName) {
      if (fieldName === _introspection.SchemaMetaFieldDef.name && schema.getQueryType() === parentType) {
        return _introspection.SchemaMetaFieldDef;
      } else if (fieldName === _introspection.TypeMetaFieldDef.name && schema.getQueryType() === parentType) {
        return _introspection.TypeMetaFieldDef;
      } else if (fieldName === _introspection.TypeNameMetaFieldDef.name) {
        return _introspection.TypeNameMetaFieldDef;
      }
      return parentType.getFields()[ fieldName ];
    }

    /***/
  }),
  /* 31 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.getVariableValues = getVariableValues;
    exports.getArgumentValues = getArgumentValues;

    var _iterall = __webpack_require__(20);

    var _error = __webpack_require__(0);

    var _invariant = __webpack_require__(3);

    var _invariant2 = _interopRequireDefault(_invariant);

    var _isNullish = __webpack_require__(6);

    var _isNullish2 = _interopRequireDefault(_isNullish);

    var _isInvalid = __webpack_require__(14);

    var _isInvalid2 = _interopRequireDefault(_isInvalid);

    var _keyMap = __webpack_require__(12);

    var _keyMap2 = _interopRequireDefault(_keyMap);

    var _typeFromAST = __webpack_require__(9);

    var _valueFromAST = __webpack_require__(16);

    var _isValidJSValue = __webpack_require__(33);

    var _isValidLiteralValue = __webpack_require__(18);

    var _kinds = __webpack_require__(2);

    var Kind = _interopRequireWildcard(_kinds);

    var _printer = __webpack_require__(4);

    var _definition = __webpack_require__(1);

    function _interopRequireWildcard(obj) {
      if (obj && obj.__esModule) {
        return obj;
      } else {
        var newObj = {};
        if (obj != null) {
          for (var key in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[ key ] = obj[ key ];
          }
        }
        newObj.default = obj;
        return newObj;
      }
    }

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    /**
     * Prepares an object map of variableValues of the correct type based on the
     * provided variable definitions and arbitrary input. If the input cannot be
     * parsed to match the variable definitions, a GraphQLError will be thrown.
     */
    function getVariableValues(schema, varDefNodes, inputs) {
      var coercedValues = Object.create(null);
      for (var i = 0; i < varDefNodes.length; i++) {
        var varDefNode = varDefNodes[ i ];
        var varName = varDefNode.variable.name.value;
        var varType = (0, _typeFromAST.typeFromAST)(schema, varDefNode.type);
        if (!(0, _definition.isInputType)(varType)) {
          throw new _error.GraphQLError('Variable "$' + varName + '" expected value of type ' + ('"' + (0, _printer.print)(varDefNode.type) + '" which cannot be used as an input type.'), [ varDefNode.type ]);
        }
        varType = varType;

        var value = inputs[ varName ];
        if ((0, _isInvalid2.default)(value)) {
          var defaultValue = varDefNode.defaultValue;
          if (defaultValue) {
            coercedValues[ varName ] = (0, _valueFromAST.valueFromAST)(defaultValue, varType);
          }
          if (varType instanceof _definition.GraphQLNonNull) {
            throw new _error.GraphQLError('Variable "$' + varName + '" of required type ' + ('"' + String(varType) + '" was not provided.'), [ varDefNode ]);
          }
        } else {
          var errors = (0, _isValidJSValue.isValidJSValue)(value, varType);
          if (errors.length) {
            var message = errors ? '\n' + errors.join('\n') : '';
            throw new _error.GraphQLError('Variable "$' + varName + '" got invalid value ' + (JSON.stringify(value) + '.' + message), [ varDefNode ]);
          }

          var coercedValue = coerceValue(varType, value);
          (0, _invariant2.default)(!(0, _isInvalid2.default)(coercedValue), 'Should have reported error.');
          coercedValues[ varName ] = coercedValue;
        }
      }
      return coercedValues;
    }

    /**
     * Prepares an object map of argument values given a list of argument
     * definitions and list of argument AST nodes.
     */

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function getArgumentValues(def, node, variableValues) {
      var argDefs = def.args;
      var argNodes = node.arguments;
      if (!argDefs || !argNodes) {
        return {};
      }
      var coercedValues = Object.create(null);
      var argNodeMap = (0, _keyMap2.default)(argNodes, function(arg) {
        return arg.name.value;
      });
      for (var i = 0; i < argDefs.length; i++) {
        var argDef = argDefs[ i ];
        var name = argDef.name;
        var argType = argDef.type;
        var argumentNode = argNodeMap[ name ];
        var defaultValue = argDef.defaultValue;
        if (!argumentNode) {
          if (!(0, _isInvalid2.default)(defaultValue)) {
            coercedValues[ name ] = defaultValue;
          } else if (argType instanceof _definition.GraphQLNonNull) {
            throw new _error.GraphQLError('Argument "' + name + '" of required type ' + ('"' + String(argType) + '" was not provided.'), [ node ]);
          }
        } else if (argumentNode.value.kind === Kind.VARIABLE) {
          var variableName = argumentNode.value.name.value;
          if (variableValues && !(0, _isInvalid2.default)(variableValues[ variableName ])) {
            // Note: this does not check that this variable value is correct.
            // This assumes that this query has been validated and the variable
            // usage here is of the correct type.
            coercedValues[ name ] = variableValues[ variableName ];
          } else if (!(0, _isInvalid2.default)(defaultValue)) {
            coercedValues[ name ] = defaultValue;
          } else if (argType instanceof _definition.GraphQLNonNull) {
            throw new _error.GraphQLError('Argument "' + name + '" of required type "' + String(argType) + '" was ' + ('provided the variable "$' + variableName + '" which was not provided ') + 'a runtime value.', [ argumentNode.value ]);
          }
        } else {
          var valueNode = argumentNode.value;
          var coercedValue = (0, _valueFromAST.valueFromAST)(valueNode, argType, variableValues);
          if ((0, _isInvalid2.default)(coercedValue)) {
            var errors = (0, _isValidLiteralValue.isValidLiteralValue)(argType, valueNode);
            var message = errors ? '\n' + errors.join('\n') : '';
            throw new _error.GraphQLError('Argument "' + name + '" got invalid value ' + (0, _printer.print)(valueNode) + '.' + message, [ argumentNode.value ]);
          }
          coercedValues[ name ] = coercedValue;
        }
      }
      return coercedValues;
    }

    /**
     * Given a type and any value, return a runtime value coerced to match the type.
     */
    function coerceValue(type, value) {
      // Ensure flow knows that we treat function params as const.
      var _value = value;

      if ((0, _isInvalid2.default)(_value)) {
        return; // Intentionally return no value.
      }

      if (type instanceof _definition.GraphQLNonNull) {
        if (_value === null) {
          return; // Intentionally return no value.
        }
        return coerceValue(type.ofType, _value);
      }

      if (_value === null) {
        // Intentionally return the value null.
        return null;
      }

      if (type instanceof _definition.GraphQLList) {
        var itemType = type.ofType;
        if ((0, _iterall.isCollection)(_value)) {
          var coercedValues = [];
          var valueIter = (0, _iterall.createIterator)(_value);
          if (!valueIter) {
            return; // Intentionally return no value.
          }
          var step = void 0;
          while (!(step = valueIter.next()).done) {
            var itemValue = coerceValue(itemType, step.value);
            if ((0, _isInvalid2.default)(itemValue)) {
              return; // Intentionally return no value.
            }
            coercedValues.push(itemValue);
          }
          return coercedValues;
        }
        var coercedValue = coerceValue(itemType, _value);
        if ((0, _isInvalid2.default)(coercedValue)) {
          return; // Intentionally return no value.
        }
        return [ coerceValue(itemType, _value) ];
      }

      if (type instanceof _definition.GraphQLInputObjectType) {
        if (typeof _value !== 'object') {
          return; // Intentionally return no value.
        }
        var coercedObj = Object.create(null);
        var fields = type.getFields();
        var fieldNames = Object.keys(fields);
        for (var i = 0; i < fieldNames.length; i++) {
          var fieldName = fieldNames[ i ];
          var field = fields[ fieldName ];
          if ((0, _isInvalid2.default)(_value[ fieldName ])) {
            if (!(0, _isInvalid2.default)(field.defaultValue)) {
              coercedObj[ fieldName ] = field.defaultValue;
            } else if (field.type instanceof _definition.GraphQLNonNull) {
              return; // Intentionally return no value.
            }
            continue;
          }
          var fieldValue = coerceValue(field.type, _value[ fieldName ]);
          if ((0, _isInvalid2.default)(fieldValue)) {
            return; // Intentionally return no value.
          }
          coercedObj[ fieldName ] = fieldValue;
        }
        return coercedObj;
      }

      (0, _invariant2.default)(type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType, 'Must be input type');

      var parsed = type.parseValue(_value);
      if ((0, _isNullish2.default)(parsed)) {
        // null or invalid values represent a failure to parse correctly,
        // in which case no value is returned.
        return;
      }

      return parsed;
    }

    /***/
  }),
  /* 32 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.buildASTSchema = buildASTSchema;
    exports.getDescription = getDescription;
    exports.buildSchema = buildSchema;

    var _find = __webpack_require__(10);

    var _find2 = _interopRequireDefault(_find);

    var _invariant = __webpack_require__(3);

    var _invariant2 = _interopRequireDefault(_invariant);

    var _keyValMap = __webpack_require__(21);

    var _keyValMap2 = _interopRequireDefault(_keyValMap);

    var _valueFromAST = __webpack_require__(16);

    var _lexer = __webpack_require__(24);

    var _parser = __webpack_require__(17);

    var _values = __webpack_require__(31);

    var _kinds = __webpack_require__(2);

    var _schema = __webpack_require__(8);

    var _scalars = __webpack_require__(7);

    var _definition = __webpack_require__(1);

    var _directives = __webpack_require__(5);

    var _introspection = __webpack_require__(11);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    function buildWrappedType(innerType, inputTypeNode) {
      if (inputTypeNode.kind === _kinds.LIST_TYPE) {
        return new _definition.GraphQLList(buildWrappedType(innerType, inputTypeNode.type));
      }
      if (inputTypeNode.kind === _kinds.NON_NULL_TYPE) {
        var wrappedType = buildWrappedType(innerType, inputTypeNode.type);
        (0, _invariant2.default)(!(wrappedType instanceof _definition.GraphQLNonNull), 'No nesting nonnull.');
        return new _definition.GraphQLNonNull(wrappedType);
      }
      return innerType;
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function getNamedTypeNode(typeNode) {
      var namedType = typeNode;
      while (namedType.kind === _kinds.LIST_TYPE || namedType.kind === _kinds.NON_NULL_TYPE) {
        namedType = namedType.type;
      }
      return namedType;
    }

    /**
     * This takes the ast of a schema document produced by the parse function in
     * src/language/parser.js.
     *
     * If no schema definition is provided, then it will look for types named Query
     * and Mutation.
     *
     * Given that AST it constructs a GraphQLSchema. The resulting schema
     * has no resolve methods, so execution will use default resolvers.
     */
    function buildASTSchema(ast) {
      if (!ast || ast.kind !== _kinds.DOCUMENT) {
        throw new Error('Must provide a document ast.');
      }

      var schemaDef = void 0;

      var typeDefs = [];
      var nodeMap = Object.create(null);
      var directiveDefs = [];
      for (var i = 0; i < ast.definitions.length; i++) {
        var d = ast.definitions[ i ];
        switch (d.kind) {
          case _kinds.SCHEMA_DEFINITION:
            if (schemaDef) {
              throw new Error('Must provide only one schema definition.');
            }
            schemaDef = d;
            break;
          case _kinds.SCALAR_TYPE_DEFINITION:
          case _kinds.OBJECT_TYPE_DEFINITION:
          case _kinds.INTERFACE_TYPE_DEFINITION:
          case _kinds.ENUM_TYPE_DEFINITION:
          case _kinds.UNION_TYPE_DEFINITION:
          case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
            typeDefs.push(d);
            nodeMap[ d.name.value ] = d;
            break;
          case _kinds.DIRECTIVE_DEFINITION:
            directiveDefs.push(d);
            break;
        }
      }

      var queryTypeName = void 0;
      var mutationTypeName = void 0;
      var subscriptionTypeName = void 0;
      if (schemaDef) {
        schemaDef.operationTypes.forEach(function(operationType) {
          var typeName = operationType.type.name.value;
          if (operationType.operation === 'query') {
            if (queryTypeName) {
              throw new Error('Must provide only one query type in schema.');
            }
            if (!nodeMap[ typeName ]) {
              throw new Error('Specified query type "' + typeName + '" not found in document.');
            }
            queryTypeName = typeName;
          } else if (operationType.operation === 'mutation') {
            if (mutationTypeName) {
              throw new Error('Must provide only one mutation type in schema.');
            }
            if (!nodeMap[ typeName ]) {
              throw new Error('Specified mutation type "' + typeName + '" not found in document.');
            }
            mutationTypeName = typeName;
          } else if (operationType.operation === 'subscription') {
            if (subscriptionTypeName) {
              throw new Error('Must provide only one subscription type in schema.');
            }
            if (!nodeMap[ typeName ]) {
              throw new Error('Specified subscription type "' + typeName + '" not found in document.');
            }
            subscriptionTypeName = typeName;
          }
        });
      } else {
        if (nodeMap.Query) {
          queryTypeName = 'Query';
        }
        if (nodeMap.Mutation) {
          mutationTypeName = 'Mutation';
        }
        if (nodeMap.Subscription) {
          subscriptionTypeName = 'Subscription';
        }
      }

      if (!queryTypeName) {
        throw new Error('Must provide schema definition with query type or a type named Query.');
      }

      var innerTypeMap = {
        String:              _scalars.GraphQLString,
        Int:                 _scalars.GraphQLInt,
        Float:               _scalars.GraphQLFloat,
        Boolean:             _scalars.GraphQLBoolean,
        ID:                  _scalars.GraphQLID,
        __Schema:            _introspection.__Schema,
        __Directive:         _introspection.__Directive,
        __DirectiveLocation: _introspection.__DirectiveLocation,
        __Type:              _introspection.__Type,
        __Field:             _introspection.__Field,
        __InputValue:        _introspection.__InputValue,
        __EnumValue:         _introspection.__EnumValue,
        __TypeKind:          _introspection.__TypeKind
      };

      var types = typeDefs.map(function(def) {
        return typeDefNamed(def.name.value);
      });

      var directives = directiveDefs.map(getDirective);

      // If specified directives were not explicitly declared, add them.
      if (!directives.some(function(directive) {
        return directive.name === 'skip';
      })) {
        directives.push(_directives.GraphQLSkipDirective);
      }

      if (!directives.some(function(directive) {
        return directive.name === 'include';
      })) {
        directives.push(_directives.GraphQLIncludeDirective);
      }

      if (!directives.some(function(directive) {
        return directive.name === 'deprecated';
      })) {
        directives.push(_directives.GraphQLDeprecatedDirective);
      }

      return new _schema.GraphQLSchema({
        query:        getObjectType(nodeMap[ queryTypeName ]),
        mutation:     mutationTypeName ? getObjectType(nodeMap[ mutationTypeName ]) : null,
        subscription: subscriptionTypeName ? getObjectType(nodeMap[ subscriptionTypeName ]) : null,
        types:        types,
        directives:   directives
      });

      function getDirective(directiveNode) {
        return new _directives.GraphQLDirective({
          name:        directiveNode.name.value,
          description: getDescription(directiveNode),
          locations:   directiveNode.locations.map(function(node) {
            return node.value;
          }),
          args:        directiveNode.arguments && makeInputValues(directiveNode.arguments)
        });
      }

      function getObjectType(typeNode) {
        var type = typeDefNamed(typeNode.name.value);
        (0, _invariant2.default)(type instanceof _definition.GraphQLObjectType, 'AST must provide object type.');
        return type;
      }

      function produceType(typeNode) {
        var typeName = getNamedTypeNode(typeNode).name.value;
        var typeDef = typeDefNamed(typeName);
        return buildWrappedType(typeDef, typeNode);
      }

      function produceInputType(typeNode) {
        var type = produceType(typeNode);
        (0, _invariant2.default)((0, _definition.isInputType)(type), 'Expected Input type.');
        return type;
      }

      function produceOutputType(typeNode) {
        var type = produceType(typeNode);
        (0, _invariant2.default)((0, _definition.isOutputType)(type), 'Expected Output type.');
        return type;
      }

      function produceObjectType(typeNode) {
        var type = produceType(typeNode);
        (0, _invariant2.default)(type instanceof _definition.GraphQLObjectType, 'Expected Object type.');
        return type;
      }

      function produceInterfaceType(typeNode) {
        var type = produceType(typeNode);
        (0, _invariant2.default)(type instanceof _definition.GraphQLInterfaceType, 'Expected Interface type.');
        return type;
      }

      function typeDefNamed(typeName) {
        if (innerTypeMap[ typeName ]) {
          return innerTypeMap[ typeName ];
        }

        if (!nodeMap[ typeName ]) {
          throw new Error('Type "' + typeName + '" not found in document.');
        }

        var innerTypeDef = makeSchemaDef(nodeMap[ typeName ]);
        if (!innerTypeDef) {
          throw new Error('Nothing constructed for "' + typeName + '".');
        }
        innerTypeMap[ typeName ] = innerTypeDef;
        return innerTypeDef;
      }

      function makeSchemaDef(def) {
        if (!def) {
          throw new Error('def must be defined');
        }
        switch (def.kind) {
          case _kinds.OBJECT_TYPE_DEFINITION:
            return makeTypeDef(def);
          case _kinds.INTERFACE_TYPE_DEFINITION:
            return makeInterfaceDef(def);
          case _kinds.ENUM_TYPE_DEFINITION:
            return makeEnumDef(def);
          case _kinds.UNION_TYPE_DEFINITION:
            return makeUnionDef(def);
          case _kinds.SCALAR_TYPE_DEFINITION:
            return makeScalarDef(def);
          case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
            return makeInputObjectDef(def);
          default:
            throw new Error('Type kind "' + def.kind + '" not supported.');
        }
      }

      function makeTypeDef(def) {
        var typeName = def.name.value;
        return new _definition.GraphQLObjectType({
          name:        typeName,
          description: getDescription(def),
          fields:      function fields() {
            return makeFieldDefMap(def);
          },
          interfaces:  function interfaces() {
            return makeImplementedInterfaces(def);
          }
        });
      }

      function makeFieldDefMap(def) {
        return (0, _keyValMap2.default)(def.fields, function(field) {
          return field.name.value;
        }, function(field) {
          return {
            type:              produceOutputType(field.type),
            description:       getDescription(field),
            args:              makeInputValues(field.arguments),
            deprecationReason: getDeprecationReason(field.directives)
          };
        });
      }

      function makeImplementedInterfaces(def) {
        return def.interfaces && def.interfaces.map(function(iface) {
          return produceInterfaceType(iface);
        });
      }

      function makeInputValues(values) {
        return (0, _keyValMap2.default)(values, function(value) {
          return value.name.value;
        }, function(value) {
          var type = produceInputType(value.type);
          return {
            type:         type,
            description:  getDescription(value),
            defaultValue: (0, _valueFromAST.valueFromAST)(value.defaultValue, type)
          };
        });
      }

      function makeInterfaceDef(def) {
        var typeName = def.name.value;
        return new _definition.GraphQLInterfaceType({
          name:        typeName,
          description: getDescription(def),
          fields:      function fields() {
            return makeFieldDefMap(def);
          },
          resolveType: cannotExecuteSchema
        });
      }

      function makeEnumDef(def) {
        var enumType = new _definition.GraphQLEnumType({
          name:        def.name.value,
          description: getDescription(def),
          values:      (0, _keyValMap2.default)(def.values, function(enumValue) {
            return enumValue.name.value;
          }, function(enumValue) {
            return {
              description:       getDescription(enumValue),
              deprecationReason: getDeprecationReason(enumValue.directives)
            };
          })
        });

        return enumType;
      }

      function makeUnionDef(def) {
        return new _definition.GraphQLUnionType({
          name:        def.name.value,
          description: getDescription(def),
          types:       def.types.map(function(t) {
            return produceObjectType(t);
          }),
          resolveType: cannotExecuteSchema
        });
      }

      function makeScalarDef(def) {
        return new _definition.GraphQLScalarType({
          name:         def.name.value,
          description:  getDescription(def),
          serialize:    function serialize() {
            return null;
          },
          // Note: validation calls the parse functions to determine if a
          // literal value is correct. Returning null would cause use of custom
          // scalars to always fail validation. Returning false causes them to
          // always pass validation.
          parseValue:   function parseValue() {
            return false;
          },
          parseLiteral: function parseLiteral() {
            return false;
          }
        });
      }

      function makeInputObjectDef(def) {
        return new _definition.GraphQLInputObjectType({
          name:        def.name.value,
          description: getDescription(def),
          fields:      function fields() {
            return makeInputValues(def.fields);
          }
        });
      }
    }

    function getDeprecationReason(directives) {
      var deprecatedAST = directives && (0, _find2.default)(directives, function(directive) {
        return directive.name.value === _directives.GraphQLDeprecatedDirective.name;
      });
      if (!deprecatedAST) {
        return;
      }

      var _getArgumentValues = (0, _values.getArgumentValues)(_directives.GraphQLDeprecatedDirective, deprecatedAST),
        reason = _getArgumentValues.reason;

      return reason;
    }

    /**
     * Given an ast node, returns its string description based on a contiguous
     * block full-line of comments preceding it.
     */
    function getDescription(node) {
      var loc = node.loc;
      if (!loc) {
        return;
      }
      var comments = [];
      var minSpaces = void 0;
      var token = loc.startToken.prev;
      while (token && token.kind === _lexer.TokenKind.COMMENT && token.next && token.prev && token.line + 1 === token.next.line && token.line !== token.prev.line) {
        var value = String(token.value);
        var spaces = leadingSpaces(value);
        if (minSpaces === undefined || spaces < minSpaces) {
          minSpaces = spaces;
        }
        comments.push(value);
        token = token.prev;
      }
      return comments.reverse().map(function(comment) {
        return comment.slice(minSpaces);
      }).join('\n');
    }

    /**
     * A helper function to build a GraphQLSchema directly from a source
     * document.
     */
    function buildSchema(source) {
      return buildASTSchema((0, _parser.parse)(source));
    }

// Count the number of spaces on the starting side of a string.
    function leadingSpaces(str) {
      var i = 0;
      for (; i < str.length; i++) {
        if (str[ i ] !== ' ') {
          break;
        }
      }
      return i;
    }

    function cannotExecuteSchema() {
      throw new Error('Generated Schema cannot use Interface or Union types for execution.');
    }

    /***/
  }),
  /* 33 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.isValidJSValue = isValidJSValue;

    var _iterall = __webpack_require__(20);

    var _invariant = __webpack_require__(3);

    var _invariant2 = _interopRequireDefault(_invariant);

    var _isNullish = __webpack_require__(6);

    var _isNullish2 = _interopRequireDefault(_isNullish);

    var _definition = __webpack_require__(1);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    /**
     * Given a JavaScript value and a GraphQL type, determine if the value will be
     * accepted for that type. This is primarily useful for validating the
     * runtime values of query variables.
     */

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function isValidJSValue(value, type) {
      // A value must be provided if the type is non-null.
      if (type instanceof _definition.GraphQLNonNull) {
        if ((0, _isNullish2.default)(value)) {
          return [ 'Expected "' + String(type) + '", found null.' ];
        }
        return isValidJSValue(value, type.ofType);
      }

      if ((0, _isNullish2.default)(value)) {
        return [];
      }

      // Lists accept a non-list value as a list of one.
      if (type instanceof _definition.GraphQLList) {
        var _ret = function() {
          var itemType = type.ofType;
          if ((0, _iterall.isCollection)(value)) {
            var _ret2 = function() {
              var errors = [];
              (0, _iterall.forEach)(value, function(item, index) {
                errors.push.apply(errors, isValidJSValue(item, itemType).map(function(error) {
                  return 'In element #' + index + ': ' + error;
                }));
              });
              return {
                v: {
                  v: errors
                }
              };
            }();

            if (typeof _ret2 === "object") return _ret2.v;
          }
          return {
            v: isValidJSValue(value, itemType)
          };
        }();

        if (typeof _ret === "object") return _ret.v;
      }

      // Input objects check each defined field.
      if (type instanceof _definition.GraphQLInputObjectType) {
        var _ret3 = function() {
          if (typeof value !== 'object' || value === null) {
            return {
              v: [ 'Expected "' + type.name + '", found not an object.' ]
            };
          }
          var fields = type.getFields();

          var errors = [];

          // Ensure every provided field is defined.
          Object.keys(value).forEach(function(providedField) {
            if (!fields[ providedField ]) {
              errors.push('In field "' + providedField + '": Unknown field.');
            }
          });

          // Ensure every defined field is valid.
          Object.keys(fields).forEach(function(fieldName) {
            var newErrors = isValidJSValue(value[ fieldName ], fields[ fieldName ].type);
            errors.push.apply(errors, newErrors.map(function(error) {
              return 'In field "' + fieldName + '": ' + error;
            }));
          });

          return {
            v: errors
          };
        }();

        if (typeof _ret3 === "object") return _ret3.v;
      }

      (0, _invariant2.default)(type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType, 'Must be input type');

      // Scalar/Enum input checks to ensure the type can parse the value to
      // a non-null value.
      try {
        var parseResult = type.parseValue(value);
        if ((0, _isNullish2.default)(parseResult)) {
          return [ 'Expected type "' + type.name + '", found ' + JSON.stringify(value) + '.' ];
        }
      } catch (error) {
        return [ 'Expected type "' + type.name + '", found ' + JSON.stringify(value) + ': ' + error.message ];
      }

      return [];
    }

    /***/
  }),
  /* 34 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.specifiedRules = undefined;

    var _UniqueOperationNames = __webpack_require__(77);

    var _LoneAnonymousOperation = __webpack_require__(64);

    var _KnownTypeNames = __webpack_require__(63);

    var _FragmentsOnCompositeTypes = __webpack_require__(59);

    var _VariablesAreInputTypes = __webpack_require__(79);

    var _ScalarLeafs = __webpack_require__(72);

    var _FieldsOnCorrectType = __webpack_require__(58);

    var _UniqueFragmentNames = __webpack_require__(75);

    var _KnownFragmentNames = __webpack_require__(62);

    var _NoUnusedFragments = __webpack_require__(67);

    var _PossibleFragmentSpreads = __webpack_require__(70);

    var _NoFragmentCycles = __webpack_require__(65);

    var _UniqueVariableNames = __webpack_require__(78);

    var _NoUndefinedVariables = __webpack_require__(66);

    var _NoUnusedVariables = __webpack_require__(68);

    var _KnownDirectives = __webpack_require__(61);

    var _UniqueDirectivesPerLocation = __webpack_require__(74);

    var _KnownArgumentNames = __webpack_require__(60);

    var _UniqueArgumentNames = __webpack_require__(73);

    var _ArgumentsOfCorrectType = __webpack_require__(56);

    var _ProvidedNonNullArguments = __webpack_require__(71);

    var _DefaultValuesOfCorrectType = __webpack_require__(57);

    var _VariablesInAllowedPosition = __webpack_require__(80);

    var _OverlappingFieldsCanBeMerged = __webpack_require__(69);

    var _UniqueInputFieldNames = __webpack_require__(76);

    /**
     * This set includes all validation rules defined by the GraphQL spec.
     */


// Spec Section: "Field Selection Merging"

// Spec Section: "Variable Default Values Are Correctly Typed"

// Spec Section: "Argument Values Type Correctness"

// Spec Section: "Argument Names"

// Spec Section: "Directives Are Defined"

// Spec Section: "All Variable Used Defined"

// Spec Section: "Fragments must not form cycles"

// Spec Section: "Fragments must be used"

// Spec Section: "Fragment Name Uniqueness"

// Spec Section: "Leaf Field Selections"

// Spec Section: "Fragments on Composite Types"

// Spec Section: "Lone Anonymous Operation"
    var specifiedRules = exports.specifiedRules = [ _UniqueOperationNames.UniqueOperationNames, _LoneAnonymousOperation.LoneAnonymousOperation, _KnownTypeNames.KnownTypeNames, _FragmentsOnCompositeTypes.FragmentsOnCompositeTypes, _VariablesAreInputTypes.VariablesAreInputTypes, _ScalarLeafs.ScalarLeafs, _FieldsOnCorrectType.FieldsOnCorrectType, _UniqueFragmentNames.UniqueFragmentNames, _KnownFragmentNames.KnownFragmentNames, _NoUnusedFragments.NoUnusedFragments, _PossibleFragmentSpreads.PossibleFragmentSpreads, _NoFragmentCycles.NoFragmentCycles, _UniqueVariableNames.UniqueVariableNames, _NoUndefinedVariables.NoUndefinedVariables, _NoUnusedVariables.NoUnusedVariables, _KnownDirectives.KnownDirectives, _UniqueDirectivesPerLocation.UniqueDirectivesPerLocation, _KnownArgumentNames.KnownArgumentNames, _UniqueArgumentNames.UniqueArgumentNames, _ArgumentsOfCorrectType.ArgumentsOfCorrectType, _ProvidedNonNullArguments.ProvidedNonNullArguments, _DefaultValuesOfCorrectType.DefaultValuesOfCorrectType, _VariablesInAllowedPosition.VariablesInAllowedPosition, _OverlappingFieldsCanBeMerged.OverlappingFieldsCanBeMerged, _UniqueInputFieldNames.UniqueInputFieldNames ];

// Spec Section: "Input Object Field Uniqueness"

// Spec Section: "All Variable Usages Are Allowed"

// Spec Section: "Argument Optionality"

// Spec Section: "Argument Uniqueness"

// Spec Section: "Directives Are Unique Per Location"

// Spec Section: "All Variables Used"

// Spec Section: "Variable Uniqueness"

// Spec Section: "Fragment spread is possible"

// Spec Section: "Fragment spread target defined"

// Spec Section: "Field Selections on Objects, Interfaces, and Unions Types"

// Spec Section: "Variables are Input Types"

// Spec Section: "Fragment Spread Type Existence"

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

// Spec Section: "Operation Name Uniqueness"

    /***/
  }),
  /* 35 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.ValidationContext = undefined;
    exports.validate = validate;
    exports.visitUsingRules = visitUsingRules;

    var _invariant = __webpack_require__(3);

    var _invariant2 = _interopRequireDefault(_invariant);

    var _error = __webpack_require__(0);

    var _visitor = __webpack_require__(15);

    var _kinds = __webpack_require__(2);

    var Kind = _interopRequireWildcard(_kinds);

    var _schema = __webpack_require__(8);

    var _TypeInfo = __webpack_require__(27);

    var _specifiedRules = __webpack_require__(34);

    function _interopRequireWildcard(obj) {
      if (obj && obj.__esModule) {
        return obj;
      } else {
        var newObj = {};
        if (obj != null) {
          for (var key in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[ key ] = obj[ key ];
          }
        }
        newObj.default = obj;
        return newObj;
      }
    }

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    /**
     * Implements the "Validation" section of the spec.
     *
     * Validation runs synchronously, returning an array of encountered errors, or
     * an empty array if no errors were encountered and the document is valid.
     *
     * A list of specific validation rules may be provided. If not provided, the
     * default list of rules defined by the GraphQL specification will be used.
     *
     * Each validation rules is a function which returns a visitor
     * (see the language/visitor API). Visitor methods are expected to return
     * GraphQLErrors, or Arrays of GraphQLErrors when invalid.
     */
    function validate(schema, ast, rules) {
      (0, _invariant2.default)(schema, 'Must provide schema');
      (0, _invariant2.default)(ast, 'Must provide document');
      (0, _invariant2.default)(schema instanceof _schema.GraphQLSchema, 'Schema must be an instance of GraphQLSchema. Also ensure that there are ' + 'not multiple versions of GraphQL installed in your node_modules directory.');
      var typeInfo = new _TypeInfo.TypeInfo(schema);
      return visitUsingRules(schema, typeInfo, ast, rules || _specifiedRules.specifiedRules);
    }

    /**
     * This uses a specialized visitor which runs multiple visitors in parallel,
     * while maintaining the visitor skip and break API.
     *
     * @internal
     */
    function visitUsingRules(schema, typeInfo, documentAST, rules) {
      var context = new ValidationContext(schema, documentAST, typeInfo);
      var visitors = rules.map(function(rule) {
        return rule(context);
      });
      // Visit the whole document with each instance of all provided rules.
      (0, _visitor.visit)(documentAST, (0, _visitor.visitWithTypeInfo)(typeInfo, (0, _visitor.visitInParallel)(visitors)));
      return context.getErrors();
    }

    /**
     * An instance of this class is passed as the "this" context to all validators,
     * allowing access to commonly useful contextual information from within a
     * validation rule.
     */
    var ValidationContext = exports.ValidationContext = function() {
      function ValidationContext(schema, ast, typeInfo) {
        _classCallCheck(this, ValidationContext);

        this._schema = schema;
        this._ast = ast;
        this._typeInfo = typeInfo;
        this._errors = [];
        this._fragmentSpreads = new Map();
        this._recursivelyReferencedFragments = new Map();
        this._variableUsages = new Map();
        this._recursiveVariableUsages = new Map();
      }

      ValidationContext.prototype.reportError = function reportError(error) {
        this._errors.push(error);
      };

      ValidationContext.prototype.getErrors = function getErrors() {
        return this._errors;
      };

      ValidationContext.prototype.getSchema = function getSchema() {
        return this._schema;
      };

      ValidationContext.prototype.getDocument = function getDocument() {
        return this._ast;
      };

      ValidationContext.prototype.getFragment = function getFragment(name) {
        var fragments = this._fragments;
        if (!fragments) {
          this._fragments = fragments = this.getDocument().definitions.reduce(function(frags, statement) {
            if (statement.kind === Kind.FRAGMENT_DEFINITION) {
              frags[ statement.name.value ] = statement;
            }
            return frags;
          }, {});
        }
        return fragments[ name ];
      };

      ValidationContext.prototype.getFragmentSpreads = function getFragmentSpreads(node) {
        var spreads = this._fragmentSpreads.get(node);
        if (!spreads) {
          spreads = [];
          var setsToVisit = [ node ];
          while (setsToVisit.length !== 0) {
            var set = setsToVisit.pop();
            for (var i = 0; i < set.selections.length; i++) {
              var selection = set.selections[ i ];
              if (selection.kind === Kind.FRAGMENT_SPREAD) {
                spreads.push(selection);
              } else if (selection.selectionSet) {
                setsToVisit.push(selection.selectionSet);
              }
            }
          }
          this._fragmentSpreads.set(node, spreads);
        }
        return spreads;
      };

      ValidationContext.prototype.getRecursivelyReferencedFragments = function getRecursivelyReferencedFragments(operation) {
        var fragments = this._recursivelyReferencedFragments.get(operation);
        if (!fragments) {
          fragments = [];
          var collectedNames = Object.create(null);
          var nodesToVisit = [ operation.selectionSet ];
          while (nodesToVisit.length !== 0) {
            var _node = nodesToVisit.pop();
            var spreads = this.getFragmentSpreads(_node);
            for (var i = 0; i < spreads.length; i++) {
              var fragName = spreads[ i ].name.value;
              if (collectedNames[ fragName ] !== true) {
                collectedNames[ fragName ] = true;
                var fragment = this.getFragment(fragName);
                if (fragment) {
                  fragments.push(fragment);
                  nodesToVisit.push(fragment.selectionSet);
                }
              }
            }
          }
          this._recursivelyReferencedFragments.set(operation, fragments);
        }
        return fragments;
      };

      ValidationContext.prototype.getVariableUsages = function getVariableUsages(node) {
        var _this = this;

        var usages = this._variableUsages.get(node);
        if (!usages) {
          (function() {
            var newUsages = [];
            var typeInfo = new _TypeInfo.TypeInfo(_this._schema);
            (0, _visitor.visit)(node, (0, _visitor.visitWithTypeInfo)(typeInfo, {
              VariableDefinition: function VariableDefinition() {
                return false;
              },
              Variable:           function Variable(variable) {
                newUsages.push({ node: variable, type: typeInfo.getInputType() });
              }
            }));
            usages = newUsages;
            _this._variableUsages.set(node, usages);
          })();
        }
        return usages;
      };

      ValidationContext.prototype.getRecursiveVariableUsages = function getRecursiveVariableUsages(operation) {
        var usages = this._recursiveVariableUsages.get(operation);
        if (!usages) {
          usages = this.getVariableUsages(operation);
          var fragments = this.getRecursivelyReferencedFragments(operation);
          for (var i = 0; i < fragments.length; i++) {
            Array.prototype.push.apply(usages, this.getVariableUsages(fragments[ i ]));
          }
          this._recursiveVariableUsages.set(operation, usages);
        }
        return usages;
      };

      ValidationContext.prototype.getType = function getType() {
        return this._typeInfo.getType();
      };

      ValidationContext.prototype.getParentType = function getParentType() {
        return this._typeInfo.getParentType();
      };

      ValidationContext.prototype.getInputType = function getInputType() {
        return this._typeInfo.getInputType();
      };

      ValidationContext.prototype.getFieldDef = function getFieldDef() {
        return this._typeInfo.getFieldDef();
      };

      ValidationContext.prototype.getDirective = function getDirective() {
        return this._typeInfo.getDirective();
      };

      ValidationContext.prototype.getArgument = function getArgument() {
        return this._typeInfo.getArgument();
      };

      return ValidationContext;
    }();

    /***/
  }),
  /* 36 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });

    var _graphql = __webpack_require__(42);

    Object.defineProperty(exports, 'graphql', {
      enumerable: true,
      get:        function get() {
        return _graphql.graphql;
      }
    });

    var _type = __webpack_require__(44);

    Object.defineProperty(exports, 'GraphQLSchema', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLSchema;
      }
    });
    Object.defineProperty(exports, 'GraphQLScalarType', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLScalarType;
      }
    });
    Object.defineProperty(exports, 'GraphQLObjectType', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLObjectType;
      }
    });
    Object.defineProperty(exports, 'GraphQLInterfaceType', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLInterfaceType;
      }
    });
    Object.defineProperty(exports, 'GraphQLUnionType', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLUnionType;
      }
    });
    Object.defineProperty(exports, 'GraphQLEnumType', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLEnumType;
      }
    });
    Object.defineProperty(exports, 'GraphQLInputObjectType', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLInputObjectType;
      }
    });
    Object.defineProperty(exports, 'GraphQLList', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLList;
      }
    });
    Object.defineProperty(exports, 'GraphQLNonNull', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLNonNull;
      }
    });
    Object.defineProperty(exports, 'GraphQLDirective', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLDirective;
      }
    });
    Object.defineProperty(exports, 'TypeKind', {
      enumerable: true,
      get:        function get() {
        return _type.TypeKind;
      }
    });
    Object.defineProperty(exports, 'DirectiveLocation', {
      enumerable: true,
      get:        function get() {
        return _type.DirectiveLocation;
      }
    });
    Object.defineProperty(exports, 'GraphQLInt', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLInt;
      }
    });
    Object.defineProperty(exports, 'GraphQLFloat', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLFloat;
      }
    });
    Object.defineProperty(exports, 'GraphQLString', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLString;
      }
    });
    Object.defineProperty(exports, 'GraphQLBoolean', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLBoolean;
      }
    });
    Object.defineProperty(exports, 'GraphQLID', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLID;
      }
    });
    Object.defineProperty(exports, 'specifiedDirectives', {
      enumerable: true,
      get:        function get() {
        return _type.specifiedDirectives;
      }
    });
    Object.defineProperty(exports, 'GraphQLIncludeDirective', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLIncludeDirective;
      }
    });
    Object.defineProperty(exports, 'GraphQLSkipDirective', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLSkipDirective;
      }
    });
    Object.defineProperty(exports, 'GraphQLDeprecatedDirective', {
      enumerable: true,
      get:        function get() {
        return _type.GraphQLDeprecatedDirective;
      }
    });
    Object.defineProperty(exports, 'DEFAULT_DEPRECATION_REASON', {
      enumerable: true,
      get:        function get() {
        return _type.DEFAULT_DEPRECATION_REASON;
      }
    });
    Object.defineProperty(exports, 'SchemaMetaFieldDef', {
      enumerable: true,
      get:        function get() {
        return _type.SchemaMetaFieldDef;
      }
    });
    Object.defineProperty(exports, 'TypeMetaFieldDef', {
      enumerable: true,
      get:        function get() {
        return _type.TypeMetaFieldDef;
      }
    });
    Object.defineProperty(exports, 'TypeNameMetaFieldDef', {
      enumerable: true,
      get:        function get() {
        return _type.TypeNameMetaFieldDef;
      }
    });
    Object.defineProperty(exports, '__Schema', {
      enumerable: true,
      get:        function get() {
        return _type.__Schema;
      }
    });
    Object.defineProperty(exports, '__Directive', {
      enumerable: true,
      get:        function get() {
        return _type.__Directive;
      }
    });
    Object.defineProperty(exports, '__DirectiveLocation', {
      enumerable: true,
      get:        function get() {
        return _type.__DirectiveLocation;
      }
    });
    Object.defineProperty(exports, '__Type', {
      enumerable: true,
      get:        function get() {
        return _type.__Type;
      }
    });
    Object.defineProperty(exports, '__Field', {
      enumerable: true,
      get:        function get() {
        return _type.__Field;
      }
    });
    Object.defineProperty(exports, '__InputValue', {
      enumerable: true,
      get:        function get() {
        return _type.__InputValue;
      }
    });
    Object.defineProperty(exports, '__EnumValue', {
      enumerable: true,
      get:        function get() {
        return _type.__EnumValue;
      }
    });
    Object.defineProperty(exports, '__TypeKind', {
      enumerable: true,
      get:        function get() {
        return _type.__TypeKind;
      }
    });
    Object.defineProperty(exports, 'isType', {
      enumerable: true,
      get:        function get() {
        return _type.isType;
      }
    });
    Object.defineProperty(exports, 'isInputType', {
      enumerable: true,
      get:        function get() {
        return _type.isInputType;
      }
    });
    Object.defineProperty(exports, 'isOutputType', {
      enumerable: true,
      get:        function get() {
        return _type.isOutputType;
      }
    });
    Object.defineProperty(exports, 'isLeafType', {
      enumerable: true,
      get:        function get() {
        return _type.isLeafType;
      }
    });
    Object.defineProperty(exports, 'isCompositeType', {
      enumerable: true,
      get:        function get() {
        return _type.isCompositeType;
      }
    });
    Object.defineProperty(exports, 'isAbstractType', {
      enumerable: true,
      get:        function get() {
        return _type.isAbstractType;
      }
    });
    Object.defineProperty(exports, 'isNamedType', {
      enumerable: true,
      get:        function get() {
        return _type.isNamedType;
      }
    });
    Object.defineProperty(exports, 'assertType', {
      enumerable: true,
      get:        function get() {
        return _type.assertType;
      }
    });
    Object.defineProperty(exports, 'assertInputType', {
      enumerable: true,
      get:        function get() {
        return _type.assertInputType;
      }
    });
    Object.defineProperty(exports, 'assertOutputType', {
      enumerable: true,
      get:        function get() {
        return _type.assertOutputType;
      }
    });
    Object.defineProperty(exports, 'assertLeafType', {
      enumerable: true,
      get:        function get() {
        return _type.assertLeafType;
      }
    });
    Object.defineProperty(exports, 'assertCompositeType', {
      enumerable: true,
      get:        function get() {
        return _type.assertCompositeType;
      }
    });
    Object.defineProperty(exports, 'assertAbstractType', {
      enumerable: true,
      get:        function get() {
        return _type.assertAbstractType;
      }
    });
    Object.defineProperty(exports, 'assertNamedType', {
      enumerable: true,
      get:        function get() {
        return _type.assertNamedType;
      }
    });
    Object.defineProperty(exports, 'getNullableType', {
      enumerable: true,
      get:        function get() {
        return _type.getNullableType;
      }
    });
    Object.defineProperty(exports, 'getNamedType', {
      enumerable: true,
      get:        function get() {
        return _type.getNamedType;
      }
    });

    var _language = __webpack_require__(43);

    Object.defineProperty(exports, 'Source', {
      enumerable: true,
      get:        function get() {
        return _language.Source;
      }
    });
    Object.defineProperty(exports, 'getLocation', {
      enumerable: true,
      get:        function get() {
        return _language.getLocation;
      }
    });
    Object.defineProperty(exports, 'parse', {
      enumerable: true,
      get:        function get() {
        return _language.parse;
      }
    });
    Object.defineProperty(exports, 'parseValue', {
      enumerable: true,
      get:        function get() {
        return _language.parseValue;
      }
    });
    Object.defineProperty(exports, 'parseType', {
      enumerable: true,
      get:        function get() {
        return _language.parseType;
      }
    });
    Object.defineProperty(exports, 'print', {
      enumerable: true,
      get:        function get() {
        return _language.print;
      }
    });
    Object.defineProperty(exports, 'visit', {
      enumerable: true,
      get:        function get() {
        return _language.visit;
      }
    });
    Object.defineProperty(exports, 'visitInParallel', {
      enumerable: true,
      get:        function get() {
        return _language.visitInParallel;
      }
    });
    Object.defineProperty(exports, 'visitWithTypeInfo', {
      enumerable: true,
      get:        function get() {
        return _language.visitWithTypeInfo;
      }
    });
    Object.defineProperty(exports, 'Kind', {
      enumerable: true,
      get:        function get() {
        return _language.Kind;
      }
    });
    Object.defineProperty(exports, 'TokenKind', {
      enumerable: true,
      get:        function get() {
        return _language.TokenKind;
      }
    });
    Object.defineProperty(exports, 'BREAK', {
      enumerable: true,
      get:        function get() {
        return _language.BREAK;
      }
    });

    var _execution = __webpack_require__(41);

    Object.defineProperty(exports, 'execute', {
      enumerable: true,
      get:        function get() {
        return _execution.execute;
      }
    });
    Object.defineProperty(exports, 'defaultFieldResolver', {
      enumerable: true,
      get:        function get() {
        return _execution.defaultFieldResolver;
      }
    });
    Object.defineProperty(exports, 'responsePathAsArray', {
      enumerable: true,
      get:        function get() {
        return _execution.responsePathAsArray;
      }
    });

    var _validation = __webpack_require__(55);

    Object.defineProperty(exports, 'validate', {
      enumerable: true,
      get:        function get() {
        return _validation.validate;
      }
    });
    Object.defineProperty(exports, 'ValidationContext', {
      enumerable: true,
      get:        function get() {
        return _validation.ValidationContext;
      }
    });
    Object.defineProperty(exports, 'specifiedRules', {
      enumerable: true,
      get:        function get() {
        return _validation.specifiedRules;
      }
    });

    var _error = __webpack_require__(0);

    Object.defineProperty(exports, 'GraphQLError', {
      enumerable: true,
      get:        function get() {
        return _error.GraphQLError;
      }
    });
    Object.defineProperty(exports, 'formatError', {
      enumerable: true,
      get:        function get() {
        return _error.formatError;
      }
    });

    var _utilities = __webpack_require__(51);

    Object.defineProperty(exports, 'introspectionQuery', {
      enumerable: true,
      get:        function get() {
        return _utilities.introspectionQuery;
      }
    });
    Object.defineProperty(exports, 'getOperationAST', {
      enumerable: true,
      get:        function get() {
        return _utilities.getOperationAST;
      }
    });
    Object.defineProperty(exports, 'buildClientSchema', {
      enumerable: true,
      get:        function get() {
        return _utilities.buildClientSchema;
      }
    });
    Object.defineProperty(exports, 'buildASTSchema', {
      enumerable: true,
      get:        function get() {
        return _utilities.buildASTSchema;
      }
    });
    Object.defineProperty(exports, 'buildSchema', {
      enumerable: true,
      get:        function get() {
        return _utilities.buildSchema;
      }
    });
    Object.defineProperty(exports, 'extendSchema', {
      enumerable: true,
      get:        function get() {
        return _utilities.extendSchema;
      }
    });
    Object.defineProperty(exports, 'printSchema', {
      enumerable: true,
      get:        function get() {
        return _utilities.printSchema;
      }
    });
    Object.defineProperty(exports, 'printType', {
      enumerable: true,
      get:        function get() {
        return _utilities.printType;
      }
    });
    Object.defineProperty(exports, 'typeFromAST', {
      enumerable: true,
      get:        function get() {
        return _utilities.typeFromAST;
      }
    });
    Object.defineProperty(exports, 'valueFromAST', {
      enumerable: true,
      get:        function get() {
        return _utilities.valueFromAST;
      }
    });
    Object.defineProperty(exports, 'astFromValue', {
      enumerable: true,
      get:        function get() {
        return _utilities.astFromValue;
      }
    });
    Object.defineProperty(exports, 'TypeInfo', {
      enumerable: true,
      get:        function get() {
        return _utilities.TypeInfo;
      }
    });
    Object.defineProperty(exports, 'isValidJSValue', {
      enumerable: true,
      get:        function get() {
        return _utilities.isValidJSValue;
      }
    });
    Object.defineProperty(exports, 'isValidLiteralValue', {
      enumerable: true,
      get:        function get() {
        return _utilities.isValidLiteralValue;
      }
    });
    Object.defineProperty(exports, 'concatAST', {
      enumerable: true,
      get:        function get() {
        return _utilities.concatAST;
      }
    });
    Object.defineProperty(exports, 'separateOperations', {
      enumerable: true,
      get:        function get() {
        return _utilities.separateOperations;
      }
    });
    Object.defineProperty(exports, 'isEqualType', {
      enumerable: true,
      get:        function get() {
        return _utilities.isEqualType;
      }
    });
    Object.defineProperty(exports, 'isTypeSubTypeOf', {
      enumerable: true,
      get:        function get() {
        return _utilities.isTypeSubTypeOf;
      }
    });
    Object.defineProperty(exports, 'doTypesOverlap', {
      enumerable: true,
      get:        function get() {
        return _utilities.doTypesOverlap;
      }
    });
    Object.defineProperty(exports, 'assertValidName', {
      enumerable: true,
      get:        function get() {
        return _utilities.assertValidName;
      }
    });
    Object.defineProperty(exports, 'findBreakingChanges', {
      enumerable: true,
      get:        function get() {
        return _utilities.findBreakingChanges;
      }
    });
    Object.defineProperty(exports, 'findDeprecatedUsages', {
      enumerable: true,
      get:        function get() {
        return _utilities.findDeprecatedUsages;
      }
    });

    /***/
  }),
  /* 37 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", { value: true });
    var graphql_1 = __webpack_require__(36);
    var hasSubscriptionOperation = function(graphQlParams) {
      var queryDoc = graphql_1.parse(graphQlParams.query);
      for (var _i = 0, _a = queryDoc.definitions; _i < _a.length; _i++) {
        var definition = _a[ _i ];
        if (definition.kind === 'OperationDefinition') {
          var operation = definition.operation;
          if (operation === 'subscription') {
            return true;
          }
        }
      }
      return false;
    };
    exports.graphQLFetcher = function(subscriptionsClient, fallbackFetcher) {
      var activeSubscriptionId = null;
      return function(graphQLParams) {
        if (subscriptionsClient && activeSubscriptionId !== null) {
          subscriptionsClient.unsubscribe(activeSubscriptionId);
        }
        if (subscriptionsClient && hasSubscriptionOperation(graphQLParams)) {
          return {
            subscribe: function(observer) {
              observer.next('Your subscription data will appear here after server publication!');
              activeSubscriptionId = subscriptionsClient.subscribe({
                query:     graphQLParams.query,
                variables: graphQLParams.variables,
              }, function(error, result) {
                if (error) {
                  observer.error(error);
                }
                else {
                  observer.next(result);
                }
              });
            },
          };
        }
        else {
          return fallbackFetcher(graphQLParams);
        }
      };
    };
//# sourceMappingURL=fetcher.js.map

    /***/
  }),
  /* 38 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.formatError = formatError;

    var _invariant = __webpack_require__(3);

    var _invariant2 = _interopRequireDefault(_invariant);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    /**
     * Given a GraphQLError, format it according to the rules described by the
     * Response Format, Errors section of the GraphQL Specification.
     */
    function formatError(error) {
      (0, _invariant2.default)(error, 'Received null or undefined error.');
      return {
        message:   error.message,
        locations: error.locations,
        path:      error.path
      };
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    /***/
  }),
  /* 39 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.locatedError = locatedError;

    var _GraphQLError = __webpack_require__(13);

    /**
     * Given an arbitrary Error, presumably thrown while attempting to execute a
     * GraphQL operation, produce a new GraphQLError aware of the location in the
     * document responsible for the original Error.
     */
    function locatedError(originalError, nodes, path) {
      // Note: this uses a brand-check to support GraphQL errors originating from
      // other contexts.
      if (originalError && originalError.path) {
        return originalError;
      }

      var message = originalError ? originalError.message || String(originalError) : 'An unknown error occurred.';
      return new _GraphQLError.GraphQLError(message, originalError && originalError.nodes || nodes, originalError && originalError.source, originalError && originalError.positions, path, originalError);
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    /***/
  }),
  /* 40 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.syntaxError = syntaxError;

    var _location = __webpack_require__(25);

    var _GraphQLError = __webpack_require__(13);

    /**
     * Produces a GraphQLError representing a syntax error, containing useful
     * descriptive information about the syntax error's position in the source.
     */

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function syntaxError(source, position, description) {
      var location = (0, _location.getLocation)(source, position);
      var error = new _GraphQLError.GraphQLError('Syntax Error ' + source.name + ' (' + location.line + ':' + location.column + ') ' + description + '\n\n' + highlightSourceAtLocation(source, location), undefined, source, [ position ]);
      return error;
    }

    /**
     * Render a helpful description of the location of the error in the GraphQL
     * Source document.
     */
    function highlightSourceAtLocation(source, location) {
      var line = location.line;
      var prevLineNum = (line - 1).toString();
      var lineNum = line.toString();
      var nextLineNum = (line + 1).toString();
      var padLen = nextLineNum.length;
      var lines = source.body.split(/\r\n|[\n\r]/g);
      return (line >= 2 ? lpad(padLen, prevLineNum) + ': ' + lines[ line - 2 ] + '\n' : '') + lpad(padLen, lineNum) + ': ' + lines[ line - 1 ] + '\n' + Array(2 + padLen + location.column).join(' ') + '^\n' + (line < lines.length ? lpad(padLen, nextLineNum) + ': ' + lines[ line ] + '\n' : '');
    }

    function lpad(len, str) {
      return Array(len - str.length + 1).join(' ') + str;
    }

    /***/
  }),
  /* 41 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });

    var _execute = __webpack_require__(30);

    Object.defineProperty(exports, 'execute', {
      enumerable: true,
      get:        function get() {
        return _execute.execute;
      }
    });
    Object.defineProperty(exports, 'defaultFieldResolver', {
      enumerable: true,
      get:        function get() {
        return _execute.defaultFieldResolver;
      }
    });
    Object.defineProperty(exports, 'responsePathAsArray', {
      enumerable: true,
      get:        function get() {
        return _execute.responsePathAsArray;
      }
    });

    /***/
  }),
  /* 42 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.graphql = graphql;

    var _source = __webpack_require__(26);

    var _parser = __webpack_require__(17);

    var _validate = __webpack_require__(35);

    var _execute = __webpack_require__(30);

    /**
     * This is the primary entry point function for fulfilling GraphQL operations
     * by parsing, validating, and executing a GraphQL document along side a
     * GraphQL schema.
     *
     * More sophisticated GraphQL servers, such as those which persist queries,
     * may wish to separate the validation and execution phases to a static time
     * tooling step, and a server runtime step.
     *
     * schema:
     *    The GraphQL type system to use when validating and executing a query.
     * requestString:
     *    A GraphQL language formatted string representing the requested operation.
     * rootValue:
     *    The value provided as the first argument to resolver functions on the top
     *    level type (e.g. the query object type).
     * variableValues:
     *    A mapping of variable name to runtime value to use for all variables
     *    defined in the requestString.
     * operationName:
     *    The name of the operation to use if requestString contains multiple
     *    possible operations. Can be omitted if requestString contains only
     *    one operation.
     */

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function graphql(schema, requestString, rootValue, contextValue, variableValues, operationName) {
      return new Promise(function(resolve) {
        var source = new _source.Source(requestString || '', 'GraphQL request');
        var documentAST = (0, _parser.parse)(source);
        var validationErrors = (0, _validate.validate)(schema, documentAST);
        if (validationErrors.length > 0) {
          resolve({ errors: validationErrors });
        } else {
          resolve((0, _execute.execute)(schema, documentAST, rootValue, contextValue, variableValues, operationName));
        }
      }).then(undefined, function(error) {
        return { errors: [ error ] };
      });
    }

    /***/
  }),
  /* 43 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.BREAK = exports.visitWithTypeInfo = exports.visitInParallel = exports.visit = exports.Source = exports.print = exports.parseType = exports.parseValue = exports.parse = exports.TokenKind = exports.createLexer = exports.Kind = exports.getLocation = undefined;

    var _location = __webpack_require__(25);

    Object.defineProperty(exports, 'getLocation', {
      enumerable: true,
      get:        function get() {
        return _location.getLocation;
      }
    });

    var _lexer = __webpack_require__(24);

    Object.defineProperty(exports, 'createLexer', {
      enumerable: true,
      get:        function get() {
        return _lexer.createLexer;
      }
    });
    Object.defineProperty(exports, 'TokenKind', {
      enumerable: true,
      get:        function get() {
        return _lexer.TokenKind;
      }
    });

    var _parser = __webpack_require__(17);

    Object.defineProperty(exports, 'parse', {
      enumerable: true,
      get:        function get() {
        return _parser.parse;
      }
    });
    Object.defineProperty(exports, 'parseValue', {
      enumerable: true,
      get:        function get() {
        return _parser.parseValue;
      }
    });
    Object.defineProperty(exports, 'parseType', {
      enumerable: true,
      get:        function get() {
        return _parser.parseType;
      }
    });

    var _printer = __webpack_require__(4);

    Object.defineProperty(exports, 'print', {
      enumerable: true,
      get:        function get() {
        return _printer.print;
      }
    });

    var _source = __webpack_require__(26);

    Object.defineProperty(exports, 'Source', {
      enumerable: true,
      get:        function get() {
        return _source.Source;
      }
    });

    var _visitor = __webpack_require__(15);

    Object.defineProperty(exports, 'visit', {
      enumerable: true,
      get:        function get() {
        return _visitor.visit;
      }
    });
    Object.defineProperty(exports, 'visitInParallel', {
      enumerable: true,
      get:        function get() {
        return _visitor.visitInParallel;
      }
    });
    Object.defineProperty(exports, 'visitWithTypeInfo', {
      enumerable: true,
      get:        function get() {
        return _visitor.visitWithTypeInfo;
      }
    });
    Object.defineProperty(exports, 'BREAK', {
      enumerable: true,
      get:        function get() {
        return _visitor.BREAK;
      }
    });

    var _kinds = __webpack_require__(2);

    var Kind = _interopRequireWildcard(_kinds);

    function _interopRequireWildcard(obj) {
      if (obj && obj.__esModule) {
        return obj;
      } else {
        var newObj = {};
        if (obj != null) {
          for (var key in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[ key ] = obj[ key ];
          }
        }
        newObj.default = obj;
        return newObj;
      }
    }

    exports.Kind = Kind;

    /***/
  }),
  /* 44 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });

    var _schema = __webpack_require__(8);

    Object.defineProperty(exports, 'GraphQLSchema', {
      enumerable: true,
      get:        function get() {
        return _schema.GraphQLSchema;
      }
    });

    var _definition = __webpack_require__(1);

    Object.defineProperty(exports, 'isType', {
      enumerable: true,
      get:        function get() {
        return _definition.isType;
      }
    });
    Object.defineProperty(exports, 'isInputType', {
      enumerable: true,
      get:        function get() {
        return _definition.isInputType;
      }
    });
    Object.defineProperty(exports, 'isOutputType', {
      enumerable: true,
      get:        function get() {
        return _definition.isOutputType;
      }
    });
    Object.defineProperty(exports, 'isLeafType', {
      enumerable: true,
      get:        function get() {
        return _definition.isLeafType;
      }
    });
    Object.defineProperty(exports, 'isCompositeType', {
      enumerable: true,
      get:        function get() {
        return _definition.isCompositeType;
      }
    });
    Object.defineProperty(exports, 'isAbstractType', {
      enumerable: true,
      get:        function get() {
        return _definition.isAbstractType;
      }
    });
    Object.defineProperty(exports, 'isNamedType', {
      enumerable: true,
      get:        function get() {
        return _definition.isNamedType;
      }
    });
    Object.defineProperty(exports, 'assertType', {
      enumerable: true,
      get:        function get() {
        return _definition.assertType;
      }
    });
    Object.defineProperty(exports, 'assertInputType', {
      enumerable: true,
      get:        function get() {
        return _definition.assertInputType;
      }
    });
    Object.defineProperty(exports, 'assertOutputType', {
      enumerable: true,
      get:        function get() {
        return _definition.assertOutputType;
      }
    });
    Object.defineProperty(exports, 'assertLeafType', {
      enumerable: true,
      get:        function get() {
        return _definition.assertLeafType;
      }
    });
    Object.defineProperty(exports, 'assertCompositeType', {
      enumerable: true,
      get:        function get() {
        return _definition.assertCompositeType;
      }
    });
    Object.defineProperty(exports, 'assertAbstractType', {
      enumerable: true,
      get:        function get() {
        return _definition.assertAbstractType;
      }
    });
    Object.defineProperty(exports, 'assertNamedType', {
      enumerable: true,
      get:        function get() {
        return _definition.assertNamedType;
      }
    });
    Object.defineProperty(exports, 'getNullableType', {
      enumerable: true,
      get:        function get() {
        return _definition.getNullableType;
      }
    });
    Object.defineProperty(exports, 'getNamedType', {
      enumerable: true,
      get:        function get() {
        return _definition.getNamedType;
      }
    });
    Object.defineProperty(exports, 'GraphQLScalarType', {
      enumerable: true,
      get:        function get() {
        return _definition.GraphQLScalarType;
      }
    });
    Object.defineProperty(exports, 'GraphQLObjectType', {
      enumerable: true,
      get:        function get() {
        return _definition.GraphQLObjectType;
      }
    });
    Object.defineProperty(exports, 'GraphQLInterfaceType', {
      enumerable: true,
      get:        function get() {
        return _definition.GraphQLInterfaceType;
      }
    });
    Object.defineProperty(exports, 'GraphQLUnionType', {
      enumerable: true,
      get:        function get() {
        return _definition.GraphQLUnionType;
      }
    });
    Object.defineProperty(exports, 'GraphQLEnumType', {
      enumerable: true,
      get:        function get() {
        return _definition.GraphQLEnumType;
      }
    });
    Object.defineProperty(exports, 'GraphQLInputObjectType', {
      enumerable: true,
      get:        function get() {
        return _definition.GraphQLInputObjectType;
      }
    });
    Object.defineProperty(exports, 'GraphQLList', {
      enumerable: true,
      get:        function get() {
        return _definition.GraphQLList;
      }
    });
    Object.defineProperty(exports, 'GraphQLNonNull', {
      enumerable: true,
      get:        function get() {
        return _definition.GraphQLNonNull;
      }
    });

    var _directives = __webpack_require__(5);

    Object.defineProperty(exports, 'DirectiveLocation', {
      enumerable: true,
      get:        function get() {
        return _directives.DirectiveLocation;
      }
    });
    Object.defineProperty(exports, 'GraphQLDirective', {
      enumerable: true,
      get:        function get() {
        return _directives.GraphQLDirective;
      }
    });
    Object.defineProperty(exports, 'specifiedDirectives', {
      enumerable: true,
      get:        function get() {
        return _directives.specifiedDirectives;
      }
    });
    Object.defineProperty(exports, 'GraphQLIncludeDirective', {
      enumerable: true,
      get:        function get() {
        return _directives.GraphQLIncludeDirective;
      }
    });
    Object.defineProperty(exports, 'GraphQLSkipDirective', {
      enumerable: true,
      get:        function get() {
        return _directives.GraphQLSkipDirective;
      }
    });
    Object.defineProperty(exports, 'GraphQLDeprecatedDirective', {
      enumerable: true,
      get:        function get() {
        return _directives.GraphQLDeprecatedDirective;
      }
    });
    Object.defineProperty(exports, 'DEFAULT_DEPRECATION_REASON', {
      enumerable: true,
      get:        function get() {
        return _directives.DEFAULT_DEPRECATION_REASON;
      }
    });

    var _scalars = __webpack_require__(7);

    Object.defineProperty(exports, 'GraphQLInt', {
      enumerable: true,
      get:        function get() {
        return _scalars.GraphQLInt;
      }
    });
    Object.defineProperty(exports, 'GraphQLFloat', {
      enumerable: true,
      get:        function get() {
        return _scalars.GraphQLFloat;
      }
    });
    Object.defineProperty(exports, 'GraphQLString', {
      enumerable: true,
      get:        function get() {
        return _scalars.GraphQLString;
      }
    });
    Object.defineProperty(exports, 'GraphQLBoolean', {
      enumerable: true,
      get:        function get() {
        return _scalars.GraphQLBoolean;
      }
    });
    Object.defineProperty(exports, 'GraphQLID', {
      enumerable: true,
      get:        function get() {
        return _scalars.GraphQLID;
      }
    });

    var _introspection = __webpack_require__(11);

    Object.defineProperty(exports, 'TypeKind', {
      enumerable: true,
      get:        function get() {
        return _introspection.TypeKind;
      }
    });
    Object.defineProperty(exports, '__Schema', {
      enumerable: true,
      get:        function get() {
        return _introspection.__Schema;
      }
    });
    Object.defineProperty(exports, '__Directive', {
      enumerable: true,
      get:        function get() {
        return _introspection.__Directive;
      }
    });
    Object.defineProperty(exports, '__DirectiveLocation', {
      enumerable: true,
      get:        function get() {
        return _introspection.__DirectiveLocation;
      }
    });
    Object.defineProperty(exports, '__Type', {
      enumerable: true,
      get:        function get() {
        return _introspection.__Type;
      }
    });
    Object.defineProperty(exports, '__Field', {
      enumerable: true,
      get:        function get() {
        return _introspection.__Field;
      }
    });
    Object.defineProperty(exports, '__InputValue', {
      enumerable: true,
      get:        function get() {
        return _introspection.__InputValue;
      }
    });
    Object.defineProperty(exports, '__EnumValue', {
      enumerable: true,
      get:        function get() {
        return _introspection.__EnumValue;
      }
    });
    Object.defineProperty(exports, '__TypeKind', {
      enumerable: true,
      get:        function get() {
        return _introspection.__TypeKind;
      }
    });
    Object.defineProperty(exports, 'SchemaMetaFieldDef', {
      enumerable: true,
      get:        function get() {
        return _introspection.SchemaMetaFieldDef;
      }
    });
    Object.defineProperty(exports, 'TypeMetaFieldDef', {
      enumerable: true,
      get:        function get() {
        return _introspection.TypeMetaFieldDef;
      }
    });
    Object.defineProperty(exports, 'TypeNameMetaFieldDef', {
      enumerable: true,
      get:        function get() {
        return _introspection.TypeNameMetaFieldDef;
      }
    });

    /***/
  }),
  /* 45 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.buildClientSchema = buildClientSchema;

    var _invariant = __webpack_require__(3);

    var _invariant2 = _interopRequireDefault(_invariant);

    var _keyMap = __webpack_require__(12);

    var _keyMap2 = _interopRequireDefault(_keyMap);

    var _keyValMap = __webpack_require__(21);

    var _keyValMap2 = _interopRequireDefault(_keyValMap);

    var _valueFromAST = __webpack_require__(16);

    var _parser = __webpack_require__(17);

    var _schema = __webpack_require__(8);

    var _definition = __webpack_require__(1);

    var _introspection = __webpack_require__(11);

    var _scalars = __webpack_require__(7);

    var _directives = __webpack_require__(5);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    /**
     * Build a GraphQLSchema for use by client tools.
     *
     * Given the result of a client running the introspection query, creates and
     * returns a GraphQLSchema instance which can be then used with all graphql-js
     * tools, but cannot be used to execute a query, as introspection does not
     * represent the "resolver", "parse" or "serialize" functions or any other
     * server-internal mechanisms.
     */
    function buildClientSchema(introspection) {

      // Get the schema from the introspection result.
      var schemaIntrospection = introspection.__schema;

      // Converts the list of types into a keyMap based on the type names.
      var typeIntrospectionMap = (0, _keyMap2.default)(schemaIntrospection.types, function(type) {
        return type.name;
      });

      // A cache to use to store the actual GraphQLType definition objects by name.
      // Initialize to the GraphQL built in scalars. All functions below are inline
      // so that this type def cache is within the scope of the closure.
      var typeDefCache = {
        String:              _scalars.GraphQLString,
        Int:                 _scalars.GraphQLInt,
        Float:               _scalars.GraphQLFloat,
        Boolean:             _scalars.GraphQLBoolean,
        ID:                  _scalars.GraphQLID,
        __Schema:            _introspection.__Schema,
        __Directive:         _introspection.__Directive,
        __DirectiveLocation: _introspection.__DirectiveLocation,
        __Type:              _introspection.__Type,
        __Field:             _introspection.__Field,
        __InputValue:        _introspection.__InputValue,
        __EnumValue:         _introspection.__EnumValue,
        __TypeKind:          _introspection.__TypeKind
      };

      // Given a type reference in introspection, return the GraphQLType instance.
      // preferring cached instances before building new instances.
      function getType(typeRef) {
        if (typeRef.kind === _introspection.TypeKind.LIST) {
          var itemRef = typeRef.ofType;
          if (!itemRef) {
            throw new Error('Decorated type deeper than introspection query.');
          }
          return new _definition.GraphQLList(getType(itemRef));
        }
        if (typeRef.kind === _introspection.TypeKind.NON_NULL) {
          var nullableRef = typeRef.ofType;
          if (!nullableRef) {
            throw new Error('Decorated type deeper than introspection query.');
          }
          var nullableType = getType(nullableRef);
          (0, _invariant2.default)(!(nullableType instanceof _definition.GraphQLNonNull), 'No nesting nonnull.');
          return new _definition.GraphQLNonNull(nullableType);
        }
        return getNamedType(typeRef.name);
      }

      function getNamedType(typeName) {
        if (typeDefCache[ typeName ]) {
          return typeDefCache[ typeName ];
        }
        var typeIntrospection = typeIntrospectionMap[ typeName ];
        if (!typeIntrospection) {
          throw new Error('Invalid or incomplete schema, unknown type: ' + typeName + '. Ensure ' + 'that a full introspection query is used in order to build a ' + 'client schema.');
        }
        var typeDef = buildType(typeIntrospection);
        typeDefCache[ typeName ] = typeDef;
        return typeDef;
      }

      function getInputType(typeRef) {
        var type = getType(typeRef);
        (0, _invariant2.default)((0, _definition.isInputType)(type), 'Introspection must provide input type for arguments.');
        return type;
      }

      function getOutputType(typeRef) {
        var type = getType(typeRef);
        (0, _invariant2.default)((0, _definition.isOutputType)(type), 'Introspection must provide output type for fields.');
        return type;
      }

      function getObjectType(typeRef) {
        var type = getType(typeRef);
        (0, _invariant2.default)(type instanceof _definition.GraphQLObjectType, 'Introspection must provide object type for possibleTypes.');
        return type;
      }

      function getInterfaceType(typeRef) {
        var type = getType(typeRef);
        (0, _invariant2.default)(type instanceof _definition.GraphQLInterfaceType, 'Introspection must provide interface type for interfaces.');
        return type;
      }

      // Given a type's introspection result, construct the correct
      // GraphQLType instance.
      function buildType(type) {
        switch (type.kind) {
          case _introspection.TypeKind.SCALAR:
            return buildScalarDef(type);
          case _introspection.TypeKind.OBJECT:
            return buildObjectDef(type);
          case _introspection.TypeKind.INTERFACE:
            return buildInterfaceDef(type);
          case _introspection.TypeKind.UNION:
            return buildUnionDef(type);
          case _introspection.TypeKind.ENUM:
            return buildEnumDef(type);
          case _introspection.TypeKind.INPUT_OBJECT:
            return buildInputObjectDef(type);
          default:
            throw new Error('Invalid or incomplete schema, unknown kind: ' + type.kind + '. Ensure ' + 'that a full introspection query is used in order to build a ' + 'client schema.');
        }
      }

      function buildScalarDef(scalarIntrospection) {
        return new _definition.GraphQLScalarType({
          name:         scalarIntrospection.name,
          description:  scalarIntrospection.description,
          serialize:    function serialize(id) {
            return id;
          },
          // Note: validation calls the parse functions to determine if a
          // literal value is correct. Returning null would cause use of custom
          // scalars to always fail validation. Returning false causes them to
          // always pass validation.
          parseValue:   function parseValue() {
            return false;
          },
          parseLiteral: function parseLiteral() {
            return false;
          }
        });
      }

      function buildObjectDef(objectIntrospection) {
        return new _definition.GraphQLObjectType({
          name:        objectIntrospection.name,
          description: objectIntrospection.description,
          interfaces:  objectIntrospection.interfaces.map(getInterfaceType),
          fields:      function fields() {
            return buildFieldDefMap(objectIntrospection);
          }
        });
      }

      function buildInterfaceDef(interfaceIntrospection) {
        return new _definition.GraphQLInterfaceType({
          name:        interfaceIntrospection.name,
          description: interfaceIntrospection.description,
          fields:      function fields() {
            return buildFieldDefMap(interfaceIntrospection);
          },
          resolveType: cannotExecuteClientSchema
        });
      }

      function buildUnionDef(unionIntrospection) {
        return new _definition.GraphQLUnionType({
          name:        unionIntrospection.name,
          description: unionIntrospection.description,
          types:       unionIntrospection.possibleTypes.map(getObjectType),
          resolveType: cannotExecuteClientSchema
        });
      }

      function buildEnumDef(enumIntrospection) {
        return new _definition.GraphQLEnumType({
          name:        enumIntrospection.name,
          description: enumIntrospection.description,
          values:      (0, _keyValMap2.default)(enumIntrospection.enumValues, function(valueIntrospection) {
            return valueIntrospection.name;
          }, function(valueIntrospection) {
            return {
              description:       valueIntrospection.description,
              deprecationReason: valueIntrospection.deprecationReason
            };
          })
        });
      }

      function buildInputObjectDef(inputObjectIntrospection) {
        return new _definition.GraphQLInputObjectType({
          name:        inputObjectIntrospection.name,
          description: inputObjectIntrospection.description,
          fields:      function fields() {
            return buildInputValueDefMap(inputObjectIntrospection.inputFields);
          }
        });
      }

      function buildFieldDefMap(typeIntrospection) {
        return (0, _keyValMap2.default)(typeIntrospection.fields, function(fieldIntrospection) {
          return fieldIntrospection.name;
        }, function(fieldIntrospection) {
          return {
            description:       fieldIntrospection.description,
            deprecationReason: fieldIntrospection.deprecationReason,
            type:              getOutputType(fieldIntrospection.type),
            args:              buildInputValueDefMap(fieldIntrospection.args)
          };
        });
      }

      function buildInputValueDefMap(inputValueIntrospections) {
        return (0, _keyValMap2.default)(inputValueIntrospections, function(inputValue) {
          return inputValue.name;
        }, buildInputValue);
      }

      function buildInputValue(inputValueIntrospection) {
        var type = getInputType(inputValueIntrospection.type);
        var defaultValue = inputValueIntrospection.defaultValue ? (0, _valueFromAST.valueFromAST)((0, _parser.parseValue)(inputValueIntrospection.defaultValue), type) : undefined;
        return {
          name:         inputValueIntrospection.name,
          description:  inputValueIntrospection.description,
          type:         type,
          defaultValue: defaultValue
        };
      }

      function buildDirective(directiveIntrospection) {
        // Support deprecated `on****` fields for building `locations`, as this
        // is used by GraphiQL which may need to support outdated servers.
        var locations = directiveIntrospection.locations ? directiveIntrospection.locations.slice() : [].concat(!directiveIntrospection.onField ? [] : [ _directives.DirectiveLocation.FIELD ], !directiveIntrospection.onOperation ? [] : [ _directives.DirectiveLocation.QUERY, _directives.DirectiveLocation.MUTATION, _directives.DirectiveLocation.SUBSCRIPTION ], !directiveIntrospection.onFragment ? [] : [ _directives.DirectiveLocation.FRAGMENT_DEFINITION, _directives.DirectiveLocation.FRAGMENT_SPREAD, _directives.DirectiveLocation.INLINE_FRAGMENT ]);
        return new _directives.GraphQLDirective({
          name:        directiveIntrospection.name,
          description: directiveIntrospection.description,
          locations:   locations,
          args:        buildInputValueDefMap(directiveIntrospection.args)
        });
      }

      // Iterate through all types, getting the type definition for each, ensuring
      // that any type not directly referenced by a field will get created.
      var types = schemaIntrospection.types.map(function(typeIntrospection) {
        return getNamedType(typeIntrospection.name);
      });

      // Get the root Query, Mutation, and Subscription types.
      var queryType = getObjectType(schemaIntrospection.queryType);

      var mutationType = schemaIntrospection.mutationType ? getObjectType(schemaIntrospection.mutationType) : null;

      var subscriptionType = schemaIntrospection.subscriptionType ? getObjectType(schemaIntrospection.subscriptionType) : null;

      // Get the directives supported by Introspection, assuming empty-set if
      // directives were not queried for.
      var directives = schemaIntrospection.directives ? schemaIntrospection.directives.map(buildDirective) : [];

      // Then produce and return a Schema with these types.
      return new _schema.GraphQLSchema({
        query:        queryType,
        mutation:     mutationType,
        subscription: subscriptionType,
        types:        types,
        directives:   directives
      });
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function cannotExecuteClientSchema() {
      throw new Error('Client Schema cannot use Interface or Union types for execution.');
    }

    /***/
  }),
  /* 46 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.concatAST = concatAST;

    /**
     * Provided a collection of ASTs, presumably each from different files,
     * concatenate the ASTs together into batched AST, useful for validating many
     * GraphQL source files which together represent one conceptual application.
     */
    function concatAST(asts) {
      var batchDefinitions = [];
      for (var i = 0; i < asts.length; i++) {
        var definitions = asts[ i ].definitions;
        for (var j = 0; j < definitions.length; j++) {
          batchDefinitions.push(definitions[ j ]);
        }
      }
      return {
        kind:        'Document',
        definitions: batchDefinitions
      };
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    /***/
  }),
  /* 47 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.extendSchema = extendSchema;

    var _invariant = __webpack_require__(3);

    var _invariant2 = _interopRequireDefault(_invariant);

    var _keyMap = __webpack_require__(12);

    var _keyMap2 = _interopRequireDefault(_keyMap);

    var _keyValMap = __webpack_require__(21);

    var _keyValMap2 = _interopRequireDefault(_keyValMap);

    var _buildASTSchema = __webpack_require__(32);

    var _valueFromAST = __webpack_require__(16);

    var _GraphQLError = __webpack_require__(13);

    var _schema = __webpack_require__(8);

    var _definition = __webpack_require__(1);

    var _directives = __webpack_require__(5);

    var _introspection = __webpack_require__(11);

    var _scalars = __webpack_require__(7);

    var _kinds = __webpack_require__(2);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    /**
     * Produces a new schema given an existing schema and a document which may
     * contain GraphQL type extensions and definitions. The original schema will
     * remain unaltered.
     *
     * Because a schema represents a graph of references, a schema cannot be
     * extended without effectively making an entire copy. We do not know until it's
     * too late if subgraphs remain unchanged.
     *
     * This algorithm copies the provided schema, applying extensions while
     * producing the copy. The original schema remains unaltered.
     */

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function extendSchema(schema, documentAST) {
      (0, _invariant2.default)(schema instanceof _schema.GraphQLSchema, 'Must provide valid GraphQLSchema');

      (0, _invariant2.default)(documentAST && documentAST.kind === _kinds.DOCUMENT, 'Must provide valid Document AST');

      // Collect the type definitions and extensions found in the document.
      var typeDefinitionMap = {};
      var typeExtensionsMap = {};

      // New directives and types are separate because a directives and types can
      // have the same name. For example, a type named "skip".
      var directiveDefinitions = [];

      for (var i = 0; i < documentAST.definitions.length; i++) {
        var def = documentAST.definitions[ i ];
        switch (def.kind) {
          case _kinds.OBJECT_TYPE_DEFINITION:
          case _kinds.INTERFACE_TYPE_DEFINITION:
          case _kinds.ENUM_TYPE_DEFINITION:
          case _kinds.UNION_TYPE_DEFINITION:
          case _kinds.SCALAR_TYPE_DEFINITION:
          case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
            // Sanity check that none of the defined types conflict with the
            // schema's existing types.
            var typeName = def.name.value;
            if (schema.getType(typeName)) {
              throw new _GraphQLError.GraphQLError('Type "' + typeName + '" already exists in the schema. It cannot also ' + 'be defined in this type definition.', [ def ]);
            }
            typeDefinitionMap[ typeName ] = def;
            break;
          case _kinds.TYPE_EXTENSION_DEFINITION:
            // Sanity check that this type extension exists within the
            // schema's existing types.
            var extendedTypeName = def.definition.name.value;
            var existingType = schema.getType(extendedTypeName);
            if (!existingType) {
              throw new _GraphQLError.GraphQLError('Cannot extend type "' + extendedTypeName + '" because it does not ' + 'exist in the existing schema.', [ def.definition ]);
            }
            if (!(existingType instanceof _definition.GraphQLObjectType)) {
              throw new _GraphQLError.GraphQLError('Cannot extend non-object type "' + extendedTypeName + '".', [ def.definition ]);
            }
            var extensions = typeExtensionsMap[ extendedTypeName ];
            if (extensions) {
              extensions.push(def);
            } else {
              extensions = [ def ];
            }
            typeExtensionsMap[ extendedTypeName ] = extensions;
            break;
          case _kinds.DIRECTIVE_DEFINITION:
            var directiveName = def.name.value;
            var existingDirective = schema.getDirective(directiveName);
            if (existingDirective) {
              throw new _GraphQLError.GraphQLError('Directive "' + directiveName + '" already exists in the schema. It ' + 'cannot be redefined.', [ def ]);
            }
            directiveDefinitions.push(def);
            break;
        }
      }

      // If this document contains no new types, extensions, or directives then
      // return the same unmodified GraphQLSchema instance.
      if (Object.keys(typeExtensionsMap).length === 0 && Object.keys(typeDefinitionMap).length === 0 && directiveDefinitions.length === 0) {
        return schema;
      }

      // A cache to use to store the actual GraphQLType definition objects by name.
      // Initialize to the GraphQL built in scalars and introspection types. All
      // functions below are inline so that this type def cache is within the scope
      // of the closure.
      var typeDefCache = {
        String:              _scalars.GraphQLString,
        Int:                 _scalars.GraphQLInt,
        Float:               _scalars.GraphQLFloat,
        Boolean:             _scalars.GraphQLBoolean,
        ID:                  _scalars.GraphQLID,
        __Schema:            _introspection.__Schema,
        __Directive:         _introspection.__Directive,
        __DirectiveLocation: _introspection.__DirectiveLocation,
        __Type:              _introspection.__Type,
        __Field:             _introspection.__Field,
        __InputValue:        _introspection.__InputValue,
        __EnumValue:         _introspection.__EnumValue,
        __TypeKind:          _introspection.__TypeKind
      };

      // Get the root Query, Mutation, and Subscription object types.
      var queryType = getTypeFromDef(schema.getQueryType());

      var existingMutationType = schema.getMutationType();
      var mutationType = existingMutationType ? getTypeFromDef(existingMutationType) : null;

      var existingSubscriptionType = schema.getSubscriptionType();
      var subscriptionType = existingSubscriptionType ? getTypeFromDef(existingSubscriptionType) : null;

      // Iterate through all types, getting the type definition for each, ensuring
      // that any type not directly referenced by a field will get created.
      var typeMap = schema.getTypeMap();
      var types = Object.keys(typeMap).map(function(typeName) {
        return getTypeFromDef(typeMap[ typeName ]);
      });

      // Do the same with new types, appending to the list of defined types.
      Object.keys(typeDefinitionMap).forEach(function(typeName) {
        types.push(getTypeFromAST(typeDefinitionMap[ typeName ]));
      });

      // Then produce and return a Schema with these types.
      return new _schema.GraphQLSchema({
        query:        queryType,
        mutation:     mutationType,
        subscription: subscriptionType,
        types:        types,
        directives:   getMergedDirectives()
      });

      // Below are functions used for producing this schema that have closed over
      // this scope and have access to the schema, cache, and newly defined types.

      function getMergedDirectives() {
        var existingDirectives = schema.getDirectives();
        (0, _invariant2.default)(existingDirectives, 'schema must have default directives');

        var newDirectives = directiveDefinitions.map(function(directiveNode) {
          return getDirective(directiveNode);
        });
        return existingDirectives.concat(newDirectives);
      }

      function getTypeFromDef(typeDef) {
        var type = _getNamedType(typeDef.name);
        (0, _invariant2.default)(type, 'Missing type from schema');
        return type;
      }

      function getTypeFromAST(node) {
        var type = _getNamedType(node.name.value);
        if (!type) {
          throw new _GraphQLError.GraphQLError('Unknown type: "' + node.name.value + '". Ensure that this type exists ' + 'either in the original schema, or is added in a type definition.', [ node ]);
        }
        return type;
      }

      function getObjectTypeFromAST(node) {
        var type = getTypeFromAST(node);
        (0, _invariant2.default)(type instanceof _definition.GraphQLObjectType, 'Must be Object type.');
        return type;
      }

      function getInterfaceTypeFromAST(node) {
        var type = getTypeFromAST(node);
        (0, _invariant2.default)(type instanceof _definition.GraphQLInterfaceType, 'Must be Interface type.');
        return type;
      }

      function getInputTypeFromAST(node) {
        var type = getTypeFromAST(node);
        (0, _invariant2.default)((0, _definition.isInputType)(type), 'Must be Input type.');
        return type;
      }

      function getOutputTypeFromAST(node) {
        var type = getTypeFromAST(node);
        (0, _invariant2.default)((0, _definition.isOutputType)(type), 'Must be Output type.');
        return type;
      }

      // Given a name, returns a type from either the existing schema or an
      // added type.
      function _getNamedType(typeName) {
        var cachedTypeDef = typeDefCache[ typeName ];
        if (cachedTypeDef) {
          return cachedTypeDef;
        }

        var existingType = schema.getType(typeName);
        if (existingType) {
          var typeDef = extendType(existingType);
          typeDefCache[ typeName ] = typeDef;
          return typeDef;
        }

        var typeNode = typeDefinitionMap[ typeName ];
        if (typeNode) {
          var _typeDef = buildType(typeNode);
          typeDefCache[ typeName ] = _typeDef;
          return _typeDef;
        }
      }

      // Given a type's introspection result, construct the correct
      // GraphQLType instance.
      function extendType(type) {
        if (type instanceof _definition.GraphQLObjectType) {
          return extendObjectType(type);
        }
        if (type instanceof _definition.GraphQLInterfaceType) {
          return extendInterfaceType(type);
        }
        if (type instanceof _definition.GraphQLUnionType) {
          return extendUnionType(type);
        }
        return type;
      }

      function extendObjectType(type) {
        return new _definition.GraphQLObjectType({
          name:        type.name,
          description: type.description,
          interfaces:  function interfaces() {
            return extendImplementedInterfaces(type);
          },
          fields:      function fields() {
            return extendFieldMap(type);
          },
          isTypeOf:    type.isTypeOf
        });
      }

      function extendInterfaceType(type) {
        return new _definition.GraphQLInterfaceType({
          name:        type.name,
          description: type.description,
          fields:      function fields() {
            return extendFieldMap(type);
          },
          resolveType: type.resolveType
        });
      }

      function extendUnionType(type) {
        return new _definition.GraphQLUnionType({
          name:        type.name,
          description: type.description,
          types:       type.getTypes().map(getTypeFromDef),
          resolveType: type.resolveType
        });
      }

      function extendImplementedInterfaces(type) {
        var interfaces = type.getInterfaces().map(getTypeFromDef);

        // If there are any extensions to the interfaces, apply those here.
        var extensions = typeExtensionsMap[ type.name ];
        if (extensions) {
          extensions.forEach(function(extension) {
            extension.definition.interfaces.forEach(function(namedType) {
              var interfaceName = namedType.name.value;
              if (interfaces.some(function(def) {
                return def.name === interfaceName;
              })) {
                throw new _GraphQLError.GraphQLError('Type "' + type.name + '" already implements "' + interfaceName + '". ' + 'It cannot also be implemented in this type extension.', [ namedType ]);
              }
              interfaces.push(getInterfaceTypeFromAST(namedType));
            });
          });
        }

        return interfaces;
      }

      function extendFieldMap(type) {
        var newFieldMap = {};
        var oldFieldMap = type.getFields();
        Object.keys(oldFieldMap).forEach(function(fieldName) {
          var field = oldFieldMap[ fieldName ];
          newFieldMap[ fieldName ] = {
            description:       field.description,
            deprecationReason: field.deprecationReason,
            type:              extendFieldType(field.type),
            args:              (0, _keyMap2.default)(field.args, function(arg) {
              return arg.name;
            }),
            resolve:           field.resolve
          };
        });

        // If there are any extensions to the fields, apply those here.
        var extensions = typeExtensionsMap[ type.name ];
        if (extensions) {
          extensions.forEach(function(extension) {
            extension.definition.fields.forEach(function(field) {
              var fieldName = field.name.value;
              if (oldFieldMap[ fieldName ]) {
                throw new _GraphQLError.GraphQLError('Field "' + type.name + '.' + fieldName + '" already exists in the ' + 'schema. It cannot also be defined in this type extension.', [ field ]);
              }
              newFieldMap[ fieldName ] = {
                description: (0, _buildASTSchema.getDescription)(field),
                type:        buildOutputFieldType(field.type),
                args:        buildInputValues(field.arguments)
              };
            });
          });
        }

        return newFieldMap;
      }

      function extendFieldType(typeDef) {
        if (typeDef instanceof _definition.GraphQLList) {
          return new _definition.GraphQLList(extendFieldType(typeDef.ofType));
        }
        if (typeDef instanceof _definition.GraphQLNonNull) {
          return new _definition.GraphQLNonNull(extendFieldType(typeDef.ofType));
        }
        return getTypeFromDef(typeDef);
      }

      function buildType(typeNode) {
        switch (typeNode.kind) {
          case _kinds.OBJECT_TYPE_DEFINITION:
            return buildObjectType(typeNode);
          case _kinds.INTERFACE_TYPE_DEFINITION:
            return buildInterfaceType(typeNode);
          case _kinds.UNION_TYPE_DEFINITION:
            return buildUnionType(typeNode);
          case _kinds.SCALAR_TYPE_DEFINITION:
            return buildScalarType(typeNode);
          case _kinds.ENUM_TYPE_DEFINITION:
            return buildEnumType(typeNode);
          case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
            return buildInputObjectType(typeNode);
        }
        throw new TypeError('Unknown type kind ' + typeNode.kind);
      }

      function buildObjectType(typeNode) {
        return new _definition.GraphQLObjectType({
          name:        typeNode.name.value,
          description: (0, _buildASTSchema.getDescription)(typeNode),
          interfaces:  function interfaces() {
            return buildImplementedInterfaces(typeNode);
          },
          fields:      function fields() {
            return buildFieldMap(typeNode);
          }
        });
      }

      function buildInterfaceType(typeNode) {
        return new _definition.GraphQLInterfaceType({
          name:        typeNode.name.value,
          description: (0, _buildASTSchema.getDescription)(typeNode),
          fields:      function fields() {
            return buildFieldMap(typeNode);
          },
          resolveType: cannotExecuteExtendedSchema
        });
      }

      function buildUnionType(typeNode) {
        return new _definition.GraphQLUnionType({
          name:        typeNode.name.value,
          description: (0, _buildASTSchema.getDescription)(typeNode),
          types:       typeNode.types.map(getObjectTypeFromAST),
          resolveType: cannotExecuteExtendedSchema
        });
      }

      function buildScalarType(typeNode) {
        return new _definition.GraphQLScalarType({
          name:         typeNode.name.value,
          description:  (0, _buildASTSchema.getDescription)(typeNode),
          serialize:    function serialize(id) {
            return id;
          },
          // Note: validation calls the parse functions to determine if a
          // literal value is correct. Returning null would cause use of custom
          // scalars to always fail validation. Returning false causes them to
          // always pass validation.
          parseValue:   function parseValue() {
            return false;
          },
          parseLiteral: function parseLiteral() {
            return false;
          }
        });
      }

      function buildEnumType(typeNode) {
        return new _definition.GraphQLEnumType({
          name:        typeNode.name.value,
          description: (0, _buildASTSchema.getDescription)(typeNode),
          values:      (0, _keyValMap2.default)(typeNode.values, function(v) {
            return v.name.value;
          }, function() {
            return {};
          })
        });
      }

      function buildInputObjectType(typeNode) {
        return new _definition.GraphQLInputObjectType({
          name:        typeNode.name.value,
          description: (0, _buildASTSchema.getDescription)(typeNode),
          fields:      function fields() {
            return buildInputValues(typeNode.fields);
          }
        });
      }

      function getDirective(directiveNode) {
        return new _directives.GraphQLDirective({
          name:      directiveNode.name.value,
          locations: directiveNode.locations.map(function(node) {
            return node.value;
          }),
          args:      directiveNode.arguments && buildInputValues(directiveNode.arguments)
        });
      }

      function buildImplementedInterfaces(typeNode) {
        return typeNode.interfaces && typeNode.interfaces.map(getInterfaceTypeFromAST);
      }

      function buildFieldMap(typeNode) {
        return (0, _keyValMap2.default)(typeNode.fields, function(field) {
          return field.name.value;
        }, function(field) {
          return {
            type:        buildOutputFieldType(field.type),
            description: (0, _buildASTSchema.getDescription)(field),
            args:        buildInputValues(field.arguments)
          };
        });
      }

      function buildInputValues(values) {
        return (0, _keyValMap2.default)(values, function(value) {
          return value.name.value;
        }, function(value) {
          var type = buildInputFieldType(value.type);
          return {
            type:         type,
            description:  (0, _buildASTSchema.getDescription)(value),
            defaultValue: (0, _valueFromAST.valueFromAST)(value.defaultValue, type)
          };
        });
      }

      function buildInputFieldType(typeNode) {
        if (typeNode.kind === _kinds.LIST_TYPE) {
          return new _definition.GraphQLList(buildInputFieldType(typeNode.type));
        }
        if (typeNode.kind === _kinds.NON_NULL_TYPE) {
          var nullableType = buildInputFieldType(typeNode.type);
          (0, _invariant2.default)(!(nullableType instanceof _definition.GraphQLNonNull), 'Must be nullable');
          return new _definition.GraphQLNonNull(nullableType);
        }
        return getInputTypeFromAST(typeNode);
      }

      function buildOutputFieldType(typeNode) {
        if (typeNode.kind === _kinds.LIST_TYPE) {
          return new _definition.GraphQLList(buildOutputFieldType(typeNode.type));
        }
        if (typeNode.kind === _kinds.NON_NULL_TYPE) {
          var nullableType = buildOutputFieldType(typeNode.type);
          (0, _invariant2.default)(!(nullableType instanceof _definition.GraphQLNonNull), 'Must be nullable');
          return new _definition.GraphQLNonNull(nullableType);
        }
        return getOutputTypeFromAST(typeNode);
      }
    }

    function cannotExecuteExtendedSchema() {
      throw new Error('Extended Schema cannot use Interface or Union types for execution.');
    }

    /***/
  }),
  /* 48 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.BreakingChangeType = undefined;
    exports.findBreakingChanges = findBreakingChanges;
    exports.findRemovedTypes = findRemovedTypes;
    exports.findTypesThatChangedKind = findTypesThatChangedKind;
    exports.findFieldsThatChangedType = findFieldsThatChangedType;
    exports.findTypesRemovedFromUnions = findTypesRemovedFromUnions;
    exports.findValuesRemovedFromEnums = findValuesRemovedFromEnums;

    var _definition = __webpack_require__(1);

    var _schema = __webpack_require__(8);

    /**
     *  Copyright (c) 2016, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    var BreakingChangeType = exports.BreakingChangeType = {
      FIELD_CHANGED_KIND:      'FIELD_CHANGED_KIND',
      FIELD_REMOVED:           'FIELD_REMOVED',
      TYPE_CHANGED_KIND:       'TYPE_CHANGED_KIND',
      TYPE_REMOVED:            'TYPE_REMOVED',
      TYPE_REMOVED_FROM_UNION: 'TYPE_REMOVED_FROM_UNION',
      VALUE_REMOVED_FROM_ENUM: 'VALUE_REMOVED_FROM_ENUM'
    };

    /**
     * Given two schemas, returns an Array containing descriptions of all the types
     * of breaking changes covered by the other functions down below.
     */
    function findBreakingChanges(oldSchema, newSchema) {
      return [].concat(findRemovedTypes(oldSchema, newSchema), findTypesThatChangedKind(oldSchema, newSchema), findFieldsThatChangedType(oldSchema, newSchema), findTypesRemovedFromUnions(oldSchema, newSchema), findValuesRemovedFromEnums(oldSchema, newSchema));
    }

    /**
     * Given two schemas, returns an Array containing descriptions of any breaking
     * changes in the newSchema related to removing an entire type.
     */
    function findRemovedTypes(oldSchema, newSchema) {
      var oldTypeMap = oldSchema.getTypeMap();
      var newTypeMap = newSchema.getTypeMap();

      var breakingChanges = [];
      Object.keys(oldTypeMap).forEach(function(typeName) {
        if (!newTypeMap[ typeName ]) {
          breakingChanges.push({
            type:        BreakingChangeType.TYPE_REMOVED,
            description: typeName + ' was removed.'
          });
        }
      });
      return breakingChanges;
    }

    /**
     * Given two schemas, returns an Array containing descriptions of any breaking
     * changes in the newSchema related to changing the type of a type.
     */
    function findTypesThatChangedKind(oldSchema, newSchema) {
      var oldTypeMap = oldSchema.getTypeMap();
      var newTypeMap = newSchema.getTypeMap();

      var breakingChanges = [];
      Object.keys(oldTypeMap).forEach(function(typeName) {
        if (!newTypeMap[ typeName ]) {
          return;
        }
        var oldType = oldTypeMap[ typeName ];
        var newType = newTypeMap[ typeName ];
        if (!(oldType instanceof newType.constructor)) {
          breakingChanges.push({
            type:        BreakingChangeType.TYPE_CHANGED_KIND,
            description: typeName + ' changed from ' + (typeKindName(oldType) + ' to ' + typeKindName(newType) + '.')
          });
        }
      });
      return breakingChanges;
    }

    function typeKindName(type) {
      if (type instanceof _definition.GraphQLScalarType) {
        return 'a Scalar type';
      }
      if (type instanceof _definition.GraphQLObjectType) {
        return 'an Object type';
      }
      if (type instanceof _definition.GraphQLInterfaceType) {
        return 'an Interface type';
      }
      if (type instanceof _definition.GraphQLUnionType) {
        return 'a Union type';
      }
      if (type instanceof _definition.GraphQLEnumType) {
        return 'an Enum type';
      }
      if (type instanceof _definition.GraphQLInputObjectType) {
        return 'an Input type';
      }
      throw new TypeError('Unknown type ' + type.constructor.name);
    }

    /**
     * Given two schemas, returns an Array containing descriptions of any breaking
     * changes in the newSchema related to the fields on a type. This includes if
     * a field has been removed from a type or if a field has changed type.
     */
    function findFieldsThatChangedType(oldSchema, newSchema) {
      var oldTypeMap = oldSchema.getTypeMap();
      var newTypeMap = newSchema.getTypeMap();

      var breakingFieldChanges = [];
      Object.keys(oldTypeMap).forEach(function(typeName) {
        var oldType = oldTypeMap[ typeName ];
        var newType = newTypeMap[ typeName ];
        if (!(oldType instanceof _definition.GraphQLObjectType || oldType instanceof _definition.GraphQLInterfaceType || oldType instanceof _definition.GraphQLInputObjectType) || !(newType instanceof oldType.constructor)) {
          return;
        }

        var oldTypeFieldsDef = oldType.getFields();
        var newTypeFieldsDef = newType.getFields();
        Object.keys(oldTypeFieldsDef).forEach(function(fieldName) {
          // Check if the field is missing on the type in the new schema.
          if (!(fieldName in newTypeFieldsDef)) {
            breakingFieldChanges.push({
              type:        BreakingChangeType.FIELD_REMOVED,
              description: typeName + '.' + fieldName + ' was removed.'
            });
          } else {
            // Check if the field's type has changed in the new schema.
            var oldFieldType = (0, _definition.getNamedType)(oldTypeFieldsDef[ fieldName ].type);
            var newFieldType = (0, _definition.getNamedType)(newTypeFieldsDef[ fieldName ].type);
            if (oldFieldType && newFieldType && oldFieldType.name !== newFieldType.name) {
              breakingFieldChanges.push({
                type:        BreakingChangeType.FIELD_CHANGED_KIND,
                description: typeName + '.' + fieldName + ' changed type from ' + (oldFieldType.name + ' to ' + newFieldType.name + '.')
              });
            }
          }
        });
      });
      return breakingFieldChanges;
    }

    /**
     * Given two schemas, returns an Array containing descriptions of any breaking
     * changes in the newSchema related to removing types from a union type.
     */
    function findTypesRemovedFromUnions(oldSchema, newSchema) {
      var oldTypeMap = oldSchema.getTypeMap();
      var newTypeMap = newSchema.getTypeMap();

      var typesRemovedFromUnion = [];
      Object.keys(oldTypeMap).forEach(function(typeName) {
        var oldType = oldTypeMap[ typeName ];
        var newType = newTypeMap[ typeName ];
        if (!(oldType instanceof _definition.GraphQLUnionType) || !(newType instanceof _definition.GraphQLUnionType)) {
          return;
        }
        var typeNamesInNewUnion = Object.create(null);
        newType.getTypes().forEach(function(type) {
          typeNamesInNewUnion[ type.name ] = true;
        });
        oldType.getTypes().forEach(function(type) {
          if (!typeNamesInNewUnion[ type.name ]) {
            typesRemovedFromUnion.push({
              type:        BreakingChangeType.TYPE_REMOVED_FROM_UNION,
              description: type.name + ' was removed from union type ' + typeName + '.'
            });
          }
        });
      });
      return typesRemovedFromUnion;
    }

    /**
     * Given two schemas, returns an Array containing descriptions of any breaking
     * changes in the newSchema related to removing values from an enum type.
     */
    function findValuesRemovedFromEnums(oldSchema, newSchema) {
      var oldTypeMap = oldSchema.getTypeMap();
      var newTypeMap = newSchema.getTypeMap();

      var valuesRemovedFromEnums = [];
      Object.keys(oldTypeMap).forEach(function(typeName) {
        var oldType = oldTypeMap[ typeName ];
        var newType = newTypeMap[ typeName ];
        if (!(oldType instanceof _definition.GraphQLEnumType) || !(newType instanceof _definition.GraphQLEnumType)) {
          return;
        }
        var valuesInNewEnum = Object.create(null);
        newType.getValues().forEach(function(value) {
          valuesInNewEnum[ value.name ] = true;
        });
        oldType.getValues().forEach(function(value) {
          if (!valuesInNewEnum[ value.name ]) {
            valuesRemovedFromEnums.push({
              type:        BreakingChangeType.VALUE_REMOVED_FROM_ENUM,
              description: value.name + ' was removed from enum type ' + typeName + '.'
            });
          }
        });
      });
      return valuesRemovedFromEnums;
    }

    /***/
  }),
  /* 49 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.findDeprecatedUsages = findDeprecatedUsages;

    var _GraphQLError = __webpack_require__(13);

    var _visitor = __webpack_require__(15);

    var _definition = __webpack_require__(1);

    var _schema = __webpack_require__(8);

    var _TypeInfo = __webpack_require__(27);

    /**
     * A validation rule which reports deprecated usages.
     *
     * Returns a list of GraphQLError instances describing each deprecated use.
     */
    function findDeprecatedUsages(schema, ast) {
      var errors = [];
      var typeInfo = new _TypeInfo.TypeInfo(schema);

      (0, _visitor.visit)(ast, (0, _visitor.visitWithTypeInfo)(typeInfo, {
        Field:     function Field(node) {
          var fieldDef = typeInfo.getFieldDef();
          if (fieldDef && fieldDef.isDeprecated) {
            var parentType = typeInfo.getParentType();
            if (parentType) {
              var reason = fieldDef.deprecationReason;
              errors.push(new _GraphQLError.GraphQLError('The field ' + parentType.name + '.' + fieldDef.name + ' is deprecated.' + (reason ? ' ' + reason : ''), [ node ]));
            }
          }
        },
        EnumValue: function EnumValue(node) {
          var enumVal = typeInfo.getEnumValue();
          if (enumVal && enumVal.isDeprecated) {
            var type = (0, _definition.getNamedType)(typeInfo.getInputType());
            if (type) {
              var reason = enumVal.deprecationReason;
              errors.push(new _GraphQLError.GraphQLError('The enum value ' + type.name + '.' + enumVal.name + ' is deprecated.' + (reason ? ' ' + reason : ''), [ node ]));
            }
          }
        }
      }));

      return errors;
    }

    /**
     *  Copyright (c) Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    /***/
  }),
  /* 50 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.getOperationAST = getOperationAST;

    var _kinds = __webpack_require__(2);

    /**
     * Returns an operation AST given a document AST and optionally an operation
     * name. If a name is not provided, an operation is only returned if only one is
     * provided in the document.
     */
    function getOperationAST(documentAST, operationName) {
      var operation = null;
      for (var i = 0; i < documentAST.definitions.length; i++) {
        var definition = documentAST.definitions[ i ];
        if (definition.kind === _kinds.OPERATION_DEFINITION) {
          if (!operationName) {
            // If no operation name was provided, only return an Operation if there
            // is one defined in the document. Upon encountering the second, return
            // null.
            if (operation) {
              return null;
            }
            operation = definition;
          } else if (definition.name && definition.name.value === operationName) {
            return definition;
          }
        }
      }
      return operation;
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    /***/
  }),
  /* 51 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });

    var _introspectionQuery = __webpack_require__(52);

    Object.defineProperty(exports, 'introspectionQuery', {
      enumerable: true,
      get:        function get() {
        return _introspectionQuery.introspectionQuery;
      }
    });

    var _getOperationAST = __webpack_require__(50);

    Object.defineProperty(exports, 'getOperationAST', {
      enumerable: true,
      get:        function get() {
        return _getOperationAST.getOperationAST;
      }
    });

    var _buildClientSchema = __webpack_require__(45);

    Object.defineProperty(exports, 'buildClientSchema', {
      enumerable: true,
      get:        function get() {
        return _buildClientSchema.buildClientSchema;
      }
    });

    var _buildASTSchema = __webpack_require__(32);

    Object.defineProperty(exports, 'buildASTSchema', {
      enumerable: true,
      get:        function get() {
        return _buildASTSchema.buildASTSchema;
      }
    });
    Object.defineProperty(exports, 'buildSchema', {
      enumerable: true,
      get:        function get() {
        return _buildASTSchema.buildSchema;
      }
    });

    var _extendSchema = __webpack_require__(47);

    Object.defineProperty(exports, 'extendSchema', {
      enumerable: true,
      get:        function get() {
        return _extendSchema.extendSchema;
      }
    });

    var _schemaPrinter = __webpack_require__(53);

    Object.defineProperty(exports, 'printSchema', {
      enumerable: true,
      get:        function get() {
        return _schemaPrinter.printSchema;
      }
    });
    Object.defineProperty(exports, 'printType', {
      enumerable: true,
      get:        function get() {
        return _schemaPrinter.printType;
      }
    });
    Object.defineProperty(exports, 'printIntrospectionSchema', {
      enumerable: true,
      get:        function get() {
        return _schemaPrinter.printIntrospectionSchema;
      }
    });

    var _typeFromAST = __webpack_require__(9);

    Object.defineProperty(exports, 'typeFromAST', {
      enumerable: true,
      get:        function get() {
        return _typeFromAST.typeFromAST;
      }
    });

    var _valueFromAST = __webpack_require__(16);

    Object.defineProperty(exports, 'valueFromAST', {
      enumerable: true,
      get:        function get() {
        return _valueFromAST.valueFromAST;
      }
    });

    var _astFromValue = __webpack_require__(29);

    Object.defineProperty(exports, 'astFromValue', {
      enumerable: true,
      get:        function get() {
        return _astFromValue.astFromValue;
      }
    });

    var _TypeInfo = __webpack_require__(27);

    Object.defineProperty(exports, 'TypeInfo', {
      enumerable: true,
      get:        function get() {
        return _TypeInfo.TypeInfo;
      }
    });

    var _isValidJSValue = __webpack_require__(33);

    Object.defineProperty(exports, 'isValidJSValue', {
      enumerable: true,
      get:        function get() {
        return _isValidJSValue.isValidJSValue;
      }
    });

    var _isValidLiteralValue = __webpack_require__(18);

    Object.defineProperty(exports, 'isValidLiteralValue', {
      enumerable: true,
      get:        function get() {
        return _isValidLiteralValue.isValidLiteralValue;
      }
    });

    var _concatAST = __webpack_require__(46);

    Object.defineProperty(exports, 'concatAST', {
      enumerable: true,
      get:        function get() {
        return _concatAST.concatAST;
      }
    });

    var _separateOperations = __webpack_require__(54);

    Object.defineProperty(exports, 'separateOperations', {
      enumerable: true,
      get:        function get() {
        return _separateOperations.separateOperations;
      }
    });

    var _typeComparators = __webpack_require__(19);

    Object.defineProperty(exports, 'isEqualType', {
      enumerable: true,
      get:        function get() {
        return _typeComparators.isEqualType;
      }
    });
    Object.defineProperty(exports, 'isTypeSubTypeOf', {
      enumerable: true,
      get:        function get() {
        return _typeComparators.isTypeSubTypeOf;
      }
    });
    Object.defineProperty(exports, 'doTypesOverlap', {
      enumerable: true,
      get:        function get() {
        return _typeComparators.doTypesOverlap;
      }
    });

    var _assertValidName = __webpack_require__(28);

    Object.defineProperty(exports, 'assertValidName', {
      enumerable: true,
      get:        function get() {
        return _assertValidName.assertValidName;
      }
    });

    var _findBreakingChanges = __webpack_require__(48);

    Object.defineProperty(exports, 'findBreakingChanges', {
      enumerable: true,
      get:        function get() {
        return _findBreakingChanges.findBreakingChanges;
      }
    });

    var _findDeprecatedUsages = __webpack_require__(49);

    Object.defineProperty(exports, 'findDeprecatedUsages', {
      enumerable: true,
      get:        function get() {
        return _findDeprecatedUsages.findDeprecatedUsages;
      }
    });

    /***/
  }),
  /* 52 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    var introspectionQuery = exports.introspectionQuery = '\n  query IntrospectionQuery {\n    __schema {\n      queryType { name }\n      mutationType { name }\n      subscriptionType { name }\n      types {\n        ...FullType\n      }\n      directives {\n        name\n        description\n        locations\n        args {\n          ...InputValue\n        }\n      }\n    }\n  }\n\n  fragment FullType on __Type {\n    kind\n    name\n    description\n    fields(includeDeprecated: true) {\n      name\n      description\n      args {\n        ...InputValue\n      }\n      type {\n        ...TypeRef\n      }\n      isDeprecated\n      deprecationReason\n    }\n    inputFields {\n      ...InputValue\n    }\n    interfaces {\n      ...TypeRef\n    }\n    enumValues(includeDeprecated: true) {\n      name\n      description\n      isDeprecated\n      deprecationReason\n    }\n    possibleTypes {\n      ...TypeRef\n    }\n  }\n\n  fragment InputValue on __InputValue {\n    name\n    description\n    type { ...TypeRef }\n    defaultValue\n  }\n\n  fragment TypeRef on __Type {\n    kind\n    name\n    ofType {\n      kind\n      name\n      ofType {\n        kind\n        name\n        ofType {\n          kind\n          name\n          ofType {\n            kind\n            name\n            ofType {\n              kind\n              name\n              ofType {\n                kind\n                name\n                ofType {\n                  kind\n                  name\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n';
    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    /***/
  }),
  /* 53 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.printSchema = printSchema;
    exports.printIntrospectionSchema = printIntrospectionSchema;
    exports.printType = printType;

    var _invariant = __webpack_require__(3);

    var _invariant2 = _interopRequireDefault(_invariant);

    var _isNullish = __webpack_require__(6);

    var _isNullish2 = _interopRequireDefault(_isNullish);

    var _isInvalid = __webpack_require__(14);

    var _isInvalid2 = _interopRequireDefault(_isInvalid);

    var _astFromValue = __webpack_require__(29);

    var _printer = __webpack_require__(4);

    var _definition = __webpack_require__(1);

    var _scalars = __webpack_require__(7);

    var _directives = __webpack_require__(5);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function printSchema(schema) {
      return printFilteredSchema(schema, function(n) {
        return !isSpecDirective(n);
      }, isDefinedType);
    }

    function printIntrospectionSchema(schema) {
      return printFilteredSchema(schema, isSpecDirective, isIntrospectionType);
    }

    function isSpecDirective(directiveName) {
      return directiveName === 'skip' || directiveName === 'include' || directiveName === 'deprecated';
    }

    function isDefinedType(typename) {
      return !isIntrospectionType(typename) && !isBuiltInScalar(typename);
    }

    function isIntrospectionType(typename) {
      return typename.indexOf('__') === 0;
    }

    function isBuiltInScalar(typename) {
      return typename === 'String' || typename === 'Boolean' || typename === 'Int' || typename === 'Float' || typename === 'ID';
    }

    function printFilteredSchema(schema, directiveFilter, typeFilter) {
      var directives = schema.getDirectives().filter(function(directive) {
        return directiveFilter(directive.name);
      });
      var typeMap = schema.getTypeMap();
      var types = Object.keys(typeMap).filter(typeFilter).sort(function(name1, name2) {
        return name1.localeCompare(name2);
      }).map(function(typeName) {
        return typeMap[ typeName ];
      });

      return [ printSchemaDefinition(schema) ].concat(directives.map(printDirective), types.map(printType)).filter(Boolean).join('\n\n') + '\n';
    }

    function printSchemaDefinition(schema) {
      if (isSchemaOfCommonNames(schema)) {
        return;
      }

      var operationTypes = [];

      var queryType = schema.getQueryType();
      if (queryType) {
        operationTypes.push('  query: ' + queryType.name);
      }

      var mutationType = schema.getMutationType();
      if (mutationType) {
        operationTypes.push('  mutation: ' + mutationType.name);
      }

      var subscriptionType = schema.getSubscriptionType();
      if (subscriptionType) {
        operationTypes.push('  subscription: ' + subscriptionType.name);
      }

      return 'schema {\n' + operationTypes.join('\n') + '\n}';
    }

    /**
     * GraphQL schema define root types for each type of operation. These types are
     * the same as any other type and can be named in any manner, however there is
     * a common naming convention:
     *
     *   schema {
 *     query: Query
 *     mutation: Mutation
 *   }
     *
     * When using this naming convention, the schema description can be omitted.
     */
    function isSchemaOfCommonNames(schema) {
      var queryType = schema.getQueryType();
      if (queryType && queryType.name !== 'Query') {
        return false;
      }

      var mutationType = schema.getMutationType();
      if (mutationType && mutationType.name !== 'Mutation') {
        return false;
      }

      var subscriptionType = schema.getSubscriptionType();
      if (subscriptionType && subscriptionType.name !== 'Subscription') {
        return false;
      }

      return true;
    }

    function printType(type) {
      if (type instanceof _definition.GraphQLScalarType) {
        return printScalar(type);
      } else if (type instanceof _definition.GraphQLObjectType) {
        return printObject(type);
      } else if (type instanceof _definition.GraphQLInterfaceType) {
        return printInterface(type);
      } else if (type instanceof _definition.GraphQLUnionType) {
        return printUnion(type);
      } else if (type instanceof _definition.GraphQLEnumType) {
        return printEnum(type);
      }
      (0, _invariant2.default)(type instanceof _definition.GraphQLInputObjectType);
      return printInputObject(type);
    }

    function printScalar(type) {
      return printDescription(type) + ('scalar ' + type.name);
    }

    function printObject(type) {
      var interfaces = type.getInterfaces();
      var implementedInterfaces = interfaces.length ? ' implements ' + interfaces.map(function(i) {
        return i.name;
      }).join(', ') : '';
      return printDescription(type) + ('type ' + type.name + implementedInterfaces + ' {\n') + printFields(type) + '\n' + '}';
    }

    function printInterface(type) {
      return printDescription(type) + ('interface ' + type.name + ' {\n') + printFields(type) + '\n' + '}';
    }

    function printUnion(type) {
      return printDescription(type) + ('union ' + type.name + ' = ' + type.getTypes().join(' | '));
    }

    function printEnum(type) {
      return printDescription(type) + ('enum ' + type.name + ' {\n') + printEnumValues(type.getValues()) + '\n' + '}';
    }

    function printEnumValues(values) {
      return values.map(function(value, i) {
        return printDescription(value, '  ', !i) + '  ' + value.name + printDeprecated(value);
      }).join('\n');
    }

    function printInputObject(type) {
      var fieldMap = type.getFields();
      var fields = Object.keys(fieldMap).map(function(fieldName) {
        return fieldMap[ fieldName ];
      });
      return printDescription(type) + ('input ' + type.name + ' {\n') + fields.map(function(f, i) {
        return printDescription(f, '  ', !i) + '  ' + printInputValue(f);
      }).join('\n') + '\n' + '}';
    }

    function printFields(type) {
      var fieldMap = type.getFields();
      var fields = Object.keys(fieldMap).map(function(fieldName) {
        return fieldMap[ fieldName ];
      });
      return fields.map(function(f, i) {
        return printDescription(f, '  ', !i) + '  ' + f.name + printArgs(f.args, '  ') + ': ' + String(f.type) + printDeprecated(f);
      }).join('\n');
    }

    function printArgs(args) {
      var indentation = arguments.length > 1 && arguments[ 1 ] !== undefined ? arguments[ 1 ] : '';

      if (args.length === 0) {
        return '';
      }

      // If every arg does not have a description, print them on one line.
      if (args.every(function(arg) {
        return !arg.description;
      })) {
        return '(' + args.map(printInputValue).join(', ') + ')';
      }

      return '(\n' + args.map(function(arg, i) {
        return printDescription(arg, '  ' + indentation, !i) + '  ' + indentation + printInputValue(arg);
      }).join('\n') + '\n' + indentation + ')';
    }

    function printInputValue(arg) {
      var argDecl = arg.name + ': ' + String(arg.type);
      if (!(0, _isInvalid2.default)(arg.defaultValue)) {
        argDecl += ' = ' + (0, _printer.print)((0, _astFromValue.astFromValue)(arg.defaultValue, arg.type));
      }
      return argDecl;
    }

    function printDirective(directive) {
      return printDescription(directive) + 'directive @' + directive.name + printArgs(directive.args) + ' on ' + directive.locations.join(' | ');
    }

    function printDeprecated(fieldOrEnumVal) {
      var reason = fieldOrEnumVal.deprecationReason;
      if ((0, _isNullish2.default)(reason)) {
        return '';
      }
      if (reason === '' || reason === _directives.DEFAULT_DEPRECATION_REASON) {
        return ' @deprecated';
      }
      return ' @deprecated(reason: ' + (0, _printer.print)((0, _astFromValue.astFromValue)(reason, _scalars.GraphQLString)) + ')';
    }

    function printDescription(def) {
      var indentation = arguments.length > 1 && arguments[ 1 ] !== undefined ? arguments[ 1 ] : '';
      var firstInBlock = arguments.length > 2 && arguments[ 2 ] !== undefined ? arguments[ 2 ] : true;

      if (!def.description) {
        return '';
      }
      var lines = def.description.split('\n');
      var description = indentation && !firstInBlock ? '\n' : '';
      for (var i = 0; i < lines.length; i++) {
        if (lines[ i ] === '') {
          description += indentation + '#\n';
        } else {
          // For > 120 character long lines, cut at space boundaries into sublines
          // of ~80 chars.
          var sublines = breakLine(lines[ i ], 120 - indentation.length);
          for (var j = 0; j < sublines.length; j++) {
            description += indentation + '# ' + sublines[ j ] + '\n';
          }
        }
      }
      return description;
    }

    function breakLine(line, len) {
      if (line.length < len + 5) {
        return [ line ];
      }
      var parts = line.split(new RegExp('((?: |^).{15,' + (len - 40) + '}(?= |$))'));
      if (parts.length < 4) {
        return [ line ];
      }
      var sublines = [ parts[ 0 ] + parts[ 1 ] + parts[ 2 ] ];
      for (var i = 3; i < parts.length; i += 2) {
        sublines.push(parts[ i ].slice(1) + parts[ i + 1 ]);
      }
      return sublines;
    }

    /***/
  }),
  /* 54 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.separateOperations = separateOperations;

    var _visitor = __webpack_require__(15);

    /**
     * separateOperations accepts a single AST document which may contain many
     * operations and fragments and returns a collection of AST documents each of
     * which contains a single operation as well the fragment definitions it
     * refers to.
     */
    function separateOperations(documentAST) {

      var operations = [];
      var depGraph = Object.create(null);
      var fromName = void 0;

      // Populate the list of operations and build a dependency graph.
      (0, _visitor.visit)(documentAST, {
        OperationDefinition: function OperationDefinition(node) {
          operations.push(node);
          fromName = opName(node);
        },
        FragmentDefinition:  function FragmentDefinition(node) {
          fromName = node.name.value;
        },
        FragmentSpread:      function FragmentSpread(node) {
          var toName = node.name.value;
          (depGraph[ fromName ] || (depGraph[ fromName ] = Object.create(null)))[ toName ] = true;
        }
      });

      // For each operation, produce a new synthesized AST which includes only what
      // is necessary for completing that operation.
      var separatedDocumentASTs = Object.create(null);
      operations.forEach(function(operation) {
        var operationName = opName(operation);
        var dependencies = Object.create(null);
        collectTransitiveDependencies(dependencies, depGraph, operationName);

        separatedDocumentASTs[ operationName ] = {
          kind:        'Document',
          definitions: documentAST.definitions.filter(function(def) {
            return def === operation || def.kind === 'FragmentDefinition' && dependencies[ def.name.value ];
          })
        };
      });

      return separatedDocumentASTs;
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

// Provides the empty string for anonymous operations.
    function opName(operation) {
      return operation.name ? operation.name.value : '';
    }

// From a dependency graph, collects a list of transitive dependencies by
// recursing through a dependency graph.
    function collectTransitiveDependencies(collected, depGraph, fromName) {
      var immediateDeps = depGraph[ fromName ];
      if (immediateDeps) {
        Object.keys(immediateDeps).forEach(function(toName) {
          if (!collected[ toName ]) {
            collected[ toName ] = true;
            collectTransitiveDependencies(collected, depGraph, toName);
          }
        });
      }
    }

    /***/
  }),
  /* 55 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });

    var _validate = __webpack_require__(35);

    Object.defineProperty(exports, 'validate', {
      enumerable: true,
      get:        function get() {
        return _validate.validate;
      }
    });
    Object.defineProperty(exports, 'ValidationContext', {
      enumerable: true,
      get:        function get() {
        return _validate.ValidationContext;
      }
    });

    var _specifiedRules = __webpack_require__(34);

    Object.defineProperty(exports, 'specifiedRules', {
      enumerable: true,
      get:        function get() {
        return _specifiedRules.specifiedRules;
      }
    });

    /***/
  }),
  /* 56 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.badValueMessage = badValueMessage;
    exports.ArgumentsOfCorrectType = ArgumentsOfCorrectType;

    var _error = __webpack_require__(0);

    var _printer = __webpack_require__(4);

    var _isValidLiteralValue = __webpack_require__(18);

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function badValueMessage(argName, type, value, verboseErrors) {
      var message = verboseErrors ? '\n' + verboseErrors.join('\n') : '';
      return 'Argument "' + argName + '" has invalid value ' + value + '.' + message;
    }

    /**
     * Argument values of correct type
     *
     * A GraphQL document is only valid if all field argument literal values are
     * of the type expected by their position.
     */
    function ArgumentsOfCorrectType(context) {
      return {
        Argument: function Argument(node) {
          var argDef = context.getArgument();
          if (argDef) {
            var errors = (0, _isValidLiteralValue.isValidLiteralValue)(argDef.type, node.value);
            if (errors && errors.length > 0) {
              context.reportError(new _error.GraphQLError(badValueMessage(node.name.value, argDef.type, (0, _printer.print)(node.value), errors), [ node.value ]));
            }
          }
          return false;
        }
      };
    }

    /***/
  }),
  /* 57 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.defaultForNonNullArgMessage = defaultForNonNullArgMessage;
    exports.badValueForDefaultArgMessage = badValueForDefaultArgMessage;
    exports.DefaultValuesOfCorrectType = DefaultValuesOfCorrectType;

    var _error = __webpack_require__(0);

    var _printer = __webpack_require__(4);

    var _definition = __webpack_require__(1);

    var _isValidLiteralValue = __webpack_require__(18);

    function defaultForNonNullArgMessage(varName, type, guessType) {
      return 'Variable "$' + varName + '" of type "' + String(type) + '" is required and ' + 'will not use the default value. ' + ('Perhaps you meant to use type "' + String(guessType) + '".');
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function badValueForDefaultArgMessage(varName, type, value, verboseErrors) {
      var message = verboseErrors ? '\n' + verboseErrors.join('\n') : '';
      return 'Variable "$' + varName + '" of type "' + String(type) + '" has invalid ' + ('default value ' + value + '.' + message);
    }

    /**
     * Variable default values of correct type
     *
     * A GraphQL document is only valid if all variable default values are of the
     * type expected by their definition.
     */
    function DefaultValuesOfCorrectType(context) {
      return {
        VariableDefinition: function VariableDefinition(node) {
          var name = node.variable.name.value;
          var defaultValue = node.defaultValue;
          var type = context.getInputType();
          if (type instanceof _definition.GraphQLNonNull && defaultValue) {
            context.reportError(new _error.GraphQLError(defaultForNonNullArgMessage(name, type, type.ofType), [ defaultValue ]));
          }
          if (type && defaultValue) {
            var errors = (0, _isValidLiteralValue.isValidLiteralValue)(type, defaultValue);
            if (errors && errors.length > 0) {
              context.reportError(new _error.GraphQLError(badValueForDefaultArgMessage(name, type, (0, _printer.print)(defaultValue), errors), [ defaultValue ]));
            }
          }
          return false;
        },

        SelectionSet:       function SelectionSet() {
          return false;
        },
        FragmentDefinition: function FragmentDefinition() {
          return false;
        }
      };
    }

    /***/
  }),
  /* 58 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.undefinedFieldMessage = undefinedFieldMessage;
    exports.FieldsOnCorrectType = FieldsOnCorrectType;

    var _error = __webpack_require__(0);

    var _suggestionList = __webpack_require__(23);

    var _suggestionList2 = _interopRequireDefault(_suggestionList);

    var _quotedOrList = __webpack_require__(22);

    var _quotedOrList2 = _interopRequireDefault(_quotedOrList);

    var _definition = __webpack_require__(1);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    function undefinedFieldMessage(fieldName, type, suggestedTypeNames, suggestedFieldNames) {
      var message = 'Cannot query field "' + fieldName + '" on type "' + type + '".';
      if (suggestedTypeNames.length !== 0) {
        var suggestions = (0, _quotedOrList2.default)(suggestedTypeNames);
        message += ' Did you mean to use an inline fragment on ' + suggestions + '?';
      } else if (suggestedFieldNames.length !== 0) {
        message += ' Did you mean ' + (0, _quotedOrList2.default)(suggestedFieldNames) + '?';
      }
      return message;
    }

    /**
     * Fields on correct type
     *
     * A GraphQL document is only valid if all fields selected are defined by the
     * parent type, or are an allowed meta field such as __typename.
     */

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function FieldsOnCorrectType(context) {
      return {
        Field: function Field(node) {
          var type = context.getParentType();
          if (type) {
            var fieldDef = context.getFieldDef();
            if (!fieldDef) {
              // This field doesn't exist, lets look for suggestions.
              var schema = context.getSchema();
              var fieldName = node.name.value;
              // First determine if there are any suggested types to condition on.
              var suggestedTypeNames = getSuggestedTypeNames(schema, type, fieldName);
              // If there are no suggested types, then perhaps this was a typo?
              var suggestedFieldNames = suggestedTypeNames.length !== 0 ? [] : getSuggestedFieldNames(schema, type, fieldName);

              // Report an error, including helpful suggestions.
              context.reportError(new _error.GraphQLError(undefinedFieldMessage(fieldName, type.name, suggestedTypeNames, suggestedFieldNames), [ node ]));
            }
          }
        }
      };
    }

    /**
     * Go through all of the implementations of type, as well as the interfaces
     * that they implement. If any of those types include the provided field,
     * suggest them, sorted by how often the type is referenced,  starting
     * with Interfaces.
     */
    function getSuggestedTypeNames(schema, type, fieldName) {
      if (type instanceof _definition.GraphQLInterfaceType || type instanceof _definition.GraphQLUnionType) {
        var _ret = function() {
          var suggestedObjectTypes = [];
          var interfaceUsageCount = Object.create(null);
          schema.getPossibleTypes(type).forEach(function(possibleType) {
            if (!possibleType.getFields()[ fieldName ]) {
              return;
            }
            // This object type defines this field.
            suggestedObjectTypes.push(possibleType.name);
            possibleType.getInterfaces().forEach(function(possibleInterface) {
              if (!possibleInterface.getFields()[ fieldName ]) {
                return;
              }
              // This interface type defines this field.
              interfaceUsageCount[ possibleInterface.name ] = (interfaceUsageCount[ possibleInterface.name ] || 0) + 1;
            });
          });

          // Suggest interface types based on how common they are.
          var suggestedInterfaceTypes = Object.keys(interfaceUsageCount).sort(function(a, b) {
            return interfaceUsageCount[ b ] - interfaceUsageCount[ a ];
          });

          // Suggest both interface and object types.
          return {
            v: suggestedInterfaceTypes.concat(suggestedObjectTypes)
          };
        }();

        if (typeof _ret === "object") return _ret.v;
      }

      // Otherwise, must be an Object type, which does not have possible fields.
      return [];
    }

    /**
     * For the field name provided, determine if there are any similar field names
     * that may be the result of a typo.
     */
    function getSuggestedFieldNames(schema, type, fieldName) {
      if (type instanceof _definition.GraphQLObjectType || type instanceof _definition.GraphQLInterfaceType) {
        var possibleFieldNames = Object.keys(type.getFields());
        return (0, _suggestionList2.default)(fieldName, possibleFieldNames);
      }
      // Otherwise, must be a Union type, which does not define fields.
      return [];
    }

    /***/
  }),
  /* 59 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.inlineFragmentOnNonCompositeErrorMessage = inlineFragmentOnNonCompositeErrorMessage;
    exports.fragmentOnNonCompositeErrorMessage = fragmentOnNonCompositeErrorMessage;
    exports.FragmentsOnCompositeTypes = FragmentsOnCompositeTypes;

    var _error = __webpack_require__(0);

    var _printer = __webpack_require__(4);

    var _definition = __webpack_require__(1);

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function inlineFragmentOnNonCompositeErrorMessage(type) {
      return 'Fragment cannot condition on non composite type "' + String(type) + '".';
    }

    function fragmentOnNonCompositeErrorMessage(fragName, type) {
      return 'Fragment "' + fragName + '" cannot condition on non composite ' + ('type "' + String(type) + '".');
    }

    /**
     * Fragments on composite type
     *
     * Fragments use a type condition to determine if they apply, since fragments
     * can only be spread into a composite type (object, interface, or union), the
     * type condition must also be a composite type.
     */
    function FragmentsOnCompositeTypes(context) {
      return {
        InlineFragment:     function InlineFragment(node) {
          var type = context.getType();
          if (node.typeCondition && type && !(0, _definition.isCompositeType)(type)) {
            context.reportError(new _error.GraphQLError(inlineFragmentOnNonCompositeErrorMessage((0, _printer.print)(node.typeCondition)), [ node.typeCondition ]));
          }
        },
        FragmentDefinition: function FragmentDefinition(node) {
          var type = context.getType();
          if (type && !(0, _definition.isCompositeType)(type)) {
            context.reportError(new _error.GraphQLError(fragmentOnNonCompositeErrorMessage(node.name.value, (0, _printer.print)(node.typeCondition)), [ node.typeCondition ]));
          }
        }
      };
    }

    /***/
  }),
  /* 60 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.unknownArgMessage = unknownArgMessage;
    exports.unknownDirectiveArgMessage = unknownDirectiveArgMessage;
    exports.KnownArgumentNames = KnownArgumentNames;

    var _error = __webpack_require__(0);

    var _find = __webpack_require__(10);

    var _find2 = _interopRequireDefault(_find);

    var _invariant = __webpack_require__(3);

    var _invariant2 = _interopRequireDefault(_invariant);

    var _suggestionList = __webpack_require__(23);

    var _suggestionList2 = _interopRequireDefault(_suggestionList);

    var _quotedOrList = __webpack_require__(22);

    var _quotedOrList2 = _interopRequireDefault(_quotedOrList);

    var _kinds = __webpack_require__(2);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    function unknownArgMessage(argName, fieldName, type, suggestedArgs) {
      var message = 'Unknown argument "' + argName + '" on field "' + fieldName + '" of ' + ('type "' + String(type) + '".');
      if (suggestedArgs.length) {
        message += ' Did you mean ' + (0, _quotedOrList2.default)(suggestedArgs) + '?';
      }
      return message;
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function unknownDirectiveArgMessage(argName, directiveName, suggestedArgs) {
      var message = 'Unknown argument "' + argName + '" on directive "@' + directiveName + '".';
      if (suggestedArgs.length) {
        message += ' Did you mean ' + (0, _quotedOrList2.default)(suggestedArgs) + '?';
      }
      return message;
    }

    /**
     * Known argument names
     *
     * A GraphQL field is only valid if all supplied arguments are defined by
     * that field.
     */
    function KnownArgumentNames(context) {
      return {
        Argument: function Argument(node, key, parent, path, ancestors) {
          var argumentOf = ancestors[ ancestors.length - 1 ];
          if (argumentOf.kind === _kinds.FIELD) {
            var fieldDef = context.getFieldDef();
            if (fieldDef) {
              var fieldArgDef = (0, _find2.default)(fieldDef.args, function(arg) {
                return arg.name === node.name.value;
              });
              if (!fieldArgDef) {
                var parentType = context.getParentType();
                (0, _invariant2.default)(parentType);
                context.reportError(new _error.GraphQLError(unknownArgMessage(node.name.value, fieldDef.name, parentType.name, (0, _suggestionList2.default)(node.name.value, fieldDef.args.map(function(arg) {
                  return arg.name;
                }))), [ node ]));
              }
            }
          } else if (argumentOf.kind === _kinds.DIRECTIVE) {
            var directive = context.getDirective();
            if (directive) {
              var directiveArgDef = (0, _find2.default)(directive.args, function(arg) {
                return arg.name === node.name.value;
              });
              if (!directiveArgDef) {
                context.reportError(new _error.GraphQLError(unknownDirectiveArgMessage(node.name.value, directive.name, (0, _suggestionList2.default)(node.name.value, directive.args.map(function(arg) {
                  return arg.name;
                }))), [ node ]));
              }
            }
          }
        }
      };
    }

    /***/
  }),
  /* 61 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.unknownDirectiveMessage = unknownDirectiveMessage;
    exports.misplacedDirectiveMessage = misplacedDirectiveMessage;
    exports.KnownDirectives = KnownDirectives;

    var _error = __webpack_require__(0);

    var _find = __webpack_require__(10);

    var _find2 = _interopRequireDefault(_find);

    var _kinds = __webpack_require__(2);

    var _directives = __webpack_require__(5);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    function unknownDirectiveMessage(directiveName) {
      return 'Unknown directive "' + directiveName + '".';
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function misplacedDirectiveMessage(directiveName, location) {
      return 'Directive "' + directiveName + '" may not be used on ' + location + '.';
    }

    /**
     * Known directives
     *
     * A GraphQL document is only valid if all `@directives` are known by the
     * schema and legally positioned.
     */
    function KnownDirectives(context) {
      return {
        Directive: function Directive(node, key, parent, path, ancestors) {
          var directiveDef = (0, _find2.default)(context.getSchema().getDirectives(), function(def) {
            return def.name === node.name.value;
          });
          if (!directiveDef) {
            context.reportError(new _error.GraphQLError(unknownDirectiveMessage(node.name.value), [ node ]));
            return;
          }
          var candidateLocation = getDirectiveLocationForASTPath(ancestors);
          if (!candidateLocation) {
            context.reportError(new _error.GraphQLError(misplacedDirectiveMessage(node.name.value, node.type), [ node ]));
          } else if (directiveDef.locations.indexOf(candidateLocation) === -1) {
            context.reportError(new _error.GraphQLError(misplacedDirectiveMessage(node.name.value, candidateLocation), [ node ]));
          }
        }
      };
    }

    function getDirectiveLocationForASTPath(ancestors) {
      var appliedTo = ancestors[ ancestors.length - 1 ];
      switch (appliedTo.kind) {
        case _kinds.OPERATION_DEFINITION:
          switch (appliedTo.operation) {
            case 'query':
              return _directives.DirectiveLocation.QUERY;
            case 'mutation':
              return _directives.DirectiveLocation.MUTATION;
            case 'subscription':
              return _directives.DirectiveLocation.SUBSCRIPTION;
          }
          break;
        case _kinds.FIELD:
          return _directives.DirectiveLocation.FIELD;
        case _kinds.FRAGMENT_SPREAD:
          return _directives.DirectiveLocation.FRAGMENT_SPREAD;
        case _kinds.INLINE_FRAGMENT:
          return _directives.DirectiveLocation.INLINE_FRAGMENT;
        case _kinds.FRAGMENT_DEFINITION:
          return _directives.DirectiveLocation.FRAGMENT_DEFINITION;
        case _kinds.SCHEMA_DEFINITION:
          return _directives.DirectiveLocation.SCHEMA;
        case _kinds.SCALAR_TYPE_DEFINITION:
          return _directives.DirectiveLocation.SCALAR;
        case _kinds.OBJECT_TYPE_DEFINITION:
          return _directives.DirectiveLocation.OBJECT;
        case _kinds.FIELD_DEFINITION:
          return _directives.DirectiveLocation.FIELD_DEFINITION;
        case _kinds.INTERFACE_TYPE_DEFINITION:
          return _directives.DirectiveLocation.INTERFACE;
        case _kinds.UNION_TYPE_DEFINITION:
          return _directives.DirectiveLocation.UNION;
        case _kinds.ENUM_TYPE_DEFINITION:
          return _directives.DirectiveLocation.ENUM;
        case _kinds.ENUM_VALUE_DEFINITION:
          return _directives.DirectiveLocation.ENUM_VALUE;
        case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
          return _directives.DirectiveLocation.INPUT_OBJECT;
        case _kinds.INPUT_VALUE_DEFINITION:
          var parentNode = ancestors[ ancestors.length - 3 ];
          return parentNode.kind === _kinds.INPUT_OBJECT_TYPE_DEFINITION ? _directives.DirectiveLocation.INPUT_FIELD_DEFINITION : _directives.DirectiveLocation.ARGUMENT_DEFINITION;
      }
    }

    /***/
  }),
  /* 62 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.unknownFragmentMessage = unknownFragmentMessage;
    exports.KnownFragmentNames = KnownFragmentNames;

    var _error = __webpack_require__(0);

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function unknownFragmentMessage(fragName) {
      return 'Unknown fragment "' + fragName + '".';
    }

    /**
     * Known fragment names
     *
     * A GraphQL document is only valid if all `...Fragment` fragment spreads refer
     * to fragments defined in the same document.
     */
    function KnownFragmentNames(context) {
      return {
        FragmentSpread: function FragmentSpread(node) {
          var fragmentName = node.name.value;
          var fragment = context.getFragment(fragmentName);
          if (!fragment) {
            context.reportError(new _error.GraphQLError(unknownFragmentMessage(fragmentName), [ node.name ]));
          }
        }
      };
    }

    /***/
  }),
  /* 63 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.unknownTypeMessage = unknownTypeMessage;
    exports.KnownTypeNames = KnownTypeNames;

    var _error = __webpack_require__(0);

    var _suggestionList = __webpack_require__(23);

    var _suggestionList2 = _interopRequireDefault(_suggestionList);

    var _quotedOrList = __webpack_require__(22);

    var _quotedOrList2 = _interopRequireDefault(_quotedOrList);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function unknownTypeMessage(type, suggestedTypes) {
      var message = 'Unknown type "' + String(type) + '".';
      if (suggestedTypes.length) {
        message += ' Did you mean ' + (0, _quotedOrList2.default)(suggestedTypes) + '?';
      }
      return message;
    }

    /**
     * Known type names
     *
     * A GraphQL document is only valid if referenced types (specifically
     * variable definitions and fragment conditions) are defined by the type schema.
     */
    function KnownTypeNames(context) {
      return {
        // TODO: when validating IDL, re-enable these. Experimental version does not
        // add unreferenced types, resulting in false-positive errors. Squelched
        // errors for now.
        ObjectTypeDefinition:      function ObjectTypeDefinition() {
          return false;
        },
        InterfaceTypeDefinition:   function InterfaceTypeDefinition() {
          return false;
        },
        UnionTypeDefinition:       function UnionTypeDefinition() {
          return false;
        },
        InputObjectTypeDefinition: function InputObjectTypeDefinition() {
          return false;
        },
        NamedType:                 function NamedType(node) {
          var schema = context.getSchema();
          var typeName = node.name.value;
          var type = schema.getType(typeName);
          if (!type) {
            context.reportError(new _error.GraphQLError(unknownTypeMessage(typeName, (0, _suggestionList2.default)(typeName, Object.keys(schema.getTypeMap()))), [ node ]));
          }
        }
      };
    }

    /***/
  }),
  /* 64 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.anonOperationNotAloneMessage = anonOperationNotAloneMessage;
    exports.LoneAnonymousOperation = LoneAnonymousOperation;

    var _error = __webpack_require__(0);

    var _kinds = __webpack_require__(2);

    function anonOperationNotAloneMessage() {
      return 'This anonymous operation must be the only defined operation.';
    }

    /**
     * Lone anonymous operation
     *
     * A GraphQL document is only valid if when it contains an anonymous operation
     * (the query short-hand) that it contains only that one operation definition.
     */

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function LoneAnonymousOperation(context) {
      var operationCount = 0;
      return {
        Document:            function Document(node) {
          operationCount = node.definitions.filter(function(definition) {
            return definition.kind === _kinds.OPERATION_DEFINITION;
          }).length;
        },
        OperationDefinition: function OperationDefinition(node) {
          if (!node.name && operationCount > 1) {
            context.reportError(new _error.GraphQLError(anonOperationNotAloneMessage(), [ node ]));
          }
        }
      };
    }

    /***/
  }),
  /* 65 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.cycleErrorMessage = cycleErrorMessage;
    exports.NoFragmentCycles = NoFragmentCycles;

    var _error = __webpack_require__(0);

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function cycleErrorMessage(fragName, spreadNames) {
      var via = spreadNames.length ? ' via ' + spreadNames.join(', ') : '';
      return 'Cannot spread fragment "' + fragName + '" within itself' + via + '.';
    }

    function NoFragmentCycles(context) {
      // Tracks already visited fragments to maintain O(N) and to ensure that cycles
      // are not redundantly reported.
      var visitedFrags = Object.create(null);

      // Array of AST nodes used to produce meaningful errors
      var spreadPath = [];

      // Position in the spread path
      var spreadPathIndexByName = Object.create(null);

      return {
        OperationDefinition: function OperationDefinition() {
          return false;
        },
        FragmentDefinition:  function FragmentDefinition(node) {
          if (!visitedFrags[ node.name.value ]) {
            detectCycleRecursive(node);
          }
          return false;
        }
      };

      // This does a straight-forward DFS to find cycles.
      // It does not terminate when a cycle was found but continues to explore
      // the graph to find all possible cycles.
      function detectCycleRecursive(fragment) {
        var fragmentName = fragment.name.value;
        visitedFrags[ fragmentName ] = true;

        var spreadNodes = context.getFragmentSpreads(fragment.selectionSet);
        if (spreadNodes.length === 0) {
          return;
        }

        spreadPathIndexByName[ fragmentName ] = spreadPath.length;

        for (var i = 0; i < spreadNodes.length; i++) {
          var spreadNode = spreadNodes[ i ];
          var spreadName = spreadNode.name.value;
          var cycleIndex = spreadPathIndexByName[ spreadName ];

          if (cycleIndex === undefined) {
            spreadPath.push(spreadNode);
            if (!visitedFrags[ spreadName ]) {
              var spreadFragment = context.getFragment(spreadName);
              if (spreadFragment) {
                detectCycleRecursive(spreadFragment);
              }
            }
            spreadPath.pop();
          } else {
            var cyclePath = spreadPath.slice(cycleIndex);
            context.reportError(new _error.GraphQLError(cycleErrorMessage(spreadName, cyclePath.map(function(s) {
              return s.name.value;
            })), cyclePath.concat(spreadNode)));
          }
        }

        spreadPathIndexByName[ fragmentName ] = undefined;
      }
    }

    /***/
  }),
  /* 66 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.undefinedVarMessage = undefinedVarMessage;
    exports.NoUndefinedVariables = NoUndefinedVariables;

    var _error = __webpack_require__(0);

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function undefinedVarMessage(varName, opName) {
      return opName ? 'Variable "$' + varName + '" is not defined by operation "' + opName + '".' : 'Variable "$' + varName + '" is not defined.';
    }

    /**
     * No undefined variables
     *
     * A GraphQL operation is only valid if all variables encountered, both directly
     * and via fragment spreads, are defined by that operation.
     */
    function NoUndefinedVariables(context) {
      var variableNameDefined = Object.create(null);

      return {
        OperationDefinition: {
          enter: function enter() {
            variableNameDefined = Object.create(null);
          },
          leave: function leave(operation) {
            var usages = context.getRecursiveVariableUsages(operation);

            usages.forEach(function(_ref) {
              var node = _ref.node;

              var varName = node.name.value;
              if (variableNameDefined[ varName ] !== true) {
                context.reportError(new _error.GraphQLError(undefinedVarMessage(varName, operation.name && operation.name.value), [ node, operation ]));
              }
            });
          }
        },
        VariableDefinition:  function VariableDefinition(node) {
          variableNameDefined[ node.variable.name.value ] = true;
        }
      };
    }

    /***/
  }),
  /* 67 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.unusedFragMessage = unusedFragMessage;
    exports.NoUnusedFragments = NoUnusedFragments;

    var _error = __webpack_require__(0);

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function unusedFragMessage(fragName) {
      return 'Fragment "' + fragName + '" is never used.';
    }

    /**
     * No unused fragments
     *
     * A GraphQL document is only valid if all fragment definitions are spread
     * within operations, or spread within other fragments spread within operations.
     */
    function NoUnusedFragments(context) {
      var operationDefs = [];
      var fragmentDefs = [];

      return {
        OperationDefinition: function OperationDefinition(node) {
          operationDefs.push(node);
          return false;
        },
        FragmentDefinition:  function FragmentDefinition(node) {
          fragmentDefs.push(node);
          return false;
        },

        Document: {
          leave: function leave() {
            var fragmentNameUsed = Object.create(null);
            operationDefs.forEach(function(operation) {
              context.getRecursivelyReferencedFragments(operation).forEach(function(fragment) {
                fragmentNameUsed[ fragment.name.value ] = true;
              });
            });

            fragmentDefs.forEach(function(fragmentDef) {
              var fragName = fragmentDef.name.value;
              if (fragmentNameUsed[ fragName ] !== true) {
                context.reportError(new _error.GraphQLError(unusedFragMessage(fragName), [ fragmentDef ]));
              }
            });
          }
        }
      };
    }

    /***/
  }),
  /* 68 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.unusedVariableMessage = unusedVariableMessage;
    exports.NoUnusedVariables = NoUnusedVariables;

    var _error = __webpack_require__(0);

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function unusedVariableMessage(varName, opName) {
      return opName ? 'Variable "$' + varName + '" is never used in operation "' + opName + '".' : 'Variable "$' + varName + '" is never used.';
    }

    /**
     * No unused variables
     *
     * A GraphQL operation is only valid if all variables defined by an operation
     * are used, either directly or within a spread fragment.
     */
    function NoUnusedVariables(context) {
      var variableDefs = [];

      return {
        OperationDefinition: {
          enter: function enter() {
            variableDefs = [];
          },
          leave: function leave(operation) {
            var variableNameUsed = Object.create(null);
            var usages = context.getRecursiveVariableUsages(operation);
            var opName = operation.name ? operation.name.value : null;

            usages.forEach(function(_ref) {
              var node = _ref.node;

              variableNameUsed[ node.name.value ] = true;
            });

            variableDefs.forEach(function(variableDef) {
              var variableName = variableDef.variable.name.value;
              if (variableNameUsed[ variableName ] !== true) {
                context.reportError(new _error.GraphQLError(unusedVariableMessage(variableName, opName), [ variableDef ]));
              }
            });
          }
        },
        VariableDefinition:  function VariableDefinition(def) {
          variableDefs.push(def);
        }
      };
    }

    /***/
  }),
  /* 69 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.fieldsConflictMessage = fieldsConflictMessage;
    exports.OverlappingFieldsCanBeMerged = OverlappingFieldsCanBeMerged;

    var _error = __webpack_require__(0);

    var _find = __webpack_require__(10);

    var _find2 = _interopRequireDefault(_find);

    var _kinds = __webpack_require__(2);

    var _printer = __webpack_require__(4);

    var _definition = __webpack_require__(1);

    var _typeFromAST = __webpack_require__(9);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function fieldsConflictMessage(responseName, reason) {
      return 'Fields "' + responseName + '" conflict because ' + reasonMessage(reason) + '. Use different aliases on the fields to fetch both if this was ' + 'intentional.';
    }

    function reasonMessage(reason) {
      if (Array.isArray(reason)) {
        return reason.map(function(_ref) {
          var responseName = _ref[ 0 ],
            subreason = _ref[ 1 ];
          return 'subfields "' + responseName + '" conflict because ' + reasonMessage(subreason);
        }).join(' and ');
      }
      return reason;
    }

    /**
     * Overlapping fields can be merged
     *
     * A selection set is only valid if all fields (including spreading any
     * fragments) either correspond to distinct response names or can be merged
     * without ambiguity.
     */
    function OverlappingFieldsCanBeMerged(context) {
      // A memoization for when two fragments are compared "between" each other for
      // conflicts. Two fragments may be compared many times, so memoizing this can
      // dramatically improve the performance of this validator.
      var comparedFragments = new PairSet();

      // A cache for the "field map" and list of fragment names found in any given
      // selection set. Selection sets may be asked for this information multiple
      // times, so this improves the performance of this validator.
      var cachedFieldsAndFragmentNames = new Map();

      return {
        SelectionSet: function SelectionSet(selectionSet) {
          var conflicts = findConflictsWithinSelectionSet(context, cachedFieldsAndFragmentNames, comparedFragments, context.getParentType(), selectionSet);
          conflicts.forEach(function(_ref2) {
            var _ref2$ = _ref2[ 0 ],
              responseName = _ref2$[ 0 ],
              reason = _ref2$[ 1 ],
              fields1 = _ref2[ 1 ],
              fields2 = _ref2[ 2 ];
            return context.reportError(new _error.GraphQLError(fieldsConflictMessage(responseName, reason), fields1.concat(fields2)));
          });
        }
      };
    }

// Field name and reason.

// Reason is a string, or a nested list of conflicts.

// Tuple defining a field node in a context.

// Map of array of those.

    /**
     * Algorithm:
     *
     * Conflicts occur when two fields exist in a query which will produce the same
     * response name, but represent differing values, thus creating a conflict.
     * The algorithm below finds all conflicts via making a series of comparisons
     * between fields. In order to compare as few fields as possible, this makes
     * a series of comparisons "within" sets of fields and "between" sets of fields.
     *
     * Given any selection set, a collection produces both a set of fields by
     * also including all inline fragments, as well as a list of fragments
     * referenced by fragment spreads.
     *
     * A) Each selection set represented in the document first compares "within" its
     * collected set of fields, finding any conflicts between every pair of
     * overlapping fields.
     * Note: This is the *only time* that a the fields "within" a set are compared
     * to each other. After this only fields "between" sets are compared.
     *
     * B) Also, if any fragment is referenced in a selection set, then a
     * comparison is made "between" the original set of fields and the
     * referenced fragment.
     *
     * C) Also, if multiple fragments are referenced, then comparisons
     * are made "between" each referenced fragment.
     *
     * D) When comparing "between" a set of fields and a referenced fragment, first
     * a comparison is made between each field in the original set of fields and
     * each field in the the referenced set of fields.
     *
     * E) Also, if any fragment is referenced in the referenced selection set,
     * then a comparison is made "between" the original set of fields and the
     * referenced fragment (recursively referring to step D).
     *
     * F) When comparing "between" two fragments, first a comparison is made between
     * each field in the first referenced set of fields and each field in the the
     * second referenced set of fields.
     *
     * G) Also, any fragments referenced by the first must be compared to the
     * second, and any fragments referenced by the second must be compared to the
     * first (recursively referring to step F).
     *
     * H) When comparing two fields, if both have selection sets, then a comparison
     * is made "between" both selection sets, first comparing the set of fields in
     * the first selection set with the set of fields in the second.
     *
     * I) Also, if any fragment is referenced in either selection set, then a
     * comparison is made "between" the other set of fields and the
     * referenced fragment.
     *
     * J) Also, if two fragments are referenced in both selection sets, then a
     * comparison is made "between" the two fragments.
     *
     */

// Find all conflicts found "within" a selection set, including those found
// via spreading in fragments. Called when visiting each SelectionSet in the
// GraphQL Document.
    function findConflictsWithinSelectionSet(context, cachedFieldsAndFragmentNames, comparedFragments, parentType, selectionSet) {
      var conflicts = [];

      var _getFieldsAndFragment = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType, selectionSet),
        fieldMap = _getFieldsAndFragment[ 0 ],
        fragmentNames = _getFieldsAndFragment[ 1 ];

      // (A) Find find all conflicts "within" the fields of this selection set.
      // Note: this is the *only place* `collectConflictsWithin` is called.

      collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, fieldMap);

      // (B) Then collect conflicts between these fields and those represented by
      // each spread fragment name found.
      for (var i = 0; i < fragmentNames.length; i++) {
        collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, false, fieldMap, fragmentNames[ i ]);
        // (C) Then compare this fragment with all other fragments found in this
        // selection set to collect conflicts between fragments spread together.
        // This compares each item in the list of fragment names to every other item
        // in that same list (except for itself).
        for (var j = i + 1; j < fragmentNames.length; j++) {
          collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, false, fragmentNames[ i ], fragmentNames[ j ]);
        }
      }
      return conflicts;
    }

// Collect all conflicts found between a set of fields and a fragment reference
// including via spreading in any nested fragments.
    function collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap, fragmentName) {
      var fragment = context.getFragment(fragmentName);
      if (!fragment) {
        return;
      }

      var _getReferencedFieldsA = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment),
        fieldMap2 = _getReferencedFieldsA[ 0 ],
        fragmentNames2 = _getReferencedFieldsA[ 1 ];

      // (D) First collect any conflicts between the provided collection of fields
      // and the collection of fields represented by the given fragment.

      collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap, fieldMap2);

      // (E) Then collect any conflicts between the provided collection of fields
      // and any fragment names found in the given fragment.
      for (var i = 0; i < fragmentNames2.length; i++) {
        collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap, fragmentNames2[ i ]);
      }
    }

// Collect all conflicts found between two fragments, including via spreading in
// any nested fragments.
    function collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fragmentName1, fragmentName2) {
      var fragment1 = context.getFragment(fragmentName1);
      var fragment2 = context.getFragment(fragmentName2);
      if (!fragment1 || !fragment2) {
        return;
      }

      // No need to compare a fragment to itself.
      if (fragment1 === fragment2) {
        return;
      }

      // Memoize so two fragments are not compared for conflicts more than once.
      if (comparedFragments.has(fragmentName1, fragmentName2, areMutuallyExclusive)) {
        return;
      }
      comparedFragments.add(fragmentName1, fragmentName2, areMutuallyExclusive);

      var _getReferencedFieldsA2 = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment1),
        fieldMap1 = _getReferencedFieldsA2[ 0 ],
        fragmentNames1 = _getReferencedFieldsA2[ 1 ];

      var _getReferencedFieldsA3 = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment2),
        fieldMap2 = _getReferencedFieldsA3[ 0 ],
        fragmentNames2 = _getReferencedFieldsA3[ 1 ];

      // (F) First, collect all conflicts between these two collections of fields
      // (not including any nested fragments).

      collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap1, fieldMap2);

      // (G) Then collect conflicts between the first fragment and any nested
      // fragments spread in the second fragment.
      for (var j = 0; j < fragmentNames2.length; j++) {
        collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fragmentName1, fragmentNames2[ j ]);
      }

      // (G) Then collect conflicts between the second fragment and any nested
      // fragments spread in the first fragment.
      for (var i = 0; i < fragmentNames1.length; i++) {
        collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fragmentNames1[ i ], fragmentName2);
      }
    }

// Find all conflicts found between two selection sets, including those found
// via spreading in fragments. Called when determining if conflicts exist
// between the sub-fields of two overlapping fields.
    function findConflictsBetweenSubSelectionSets(context, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, parentType1, selectionSet1, parentType2, selectionSet2) {
      var conflicts = [];

      var _getFieldsAndFragment2 = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType1, selectionSet1),
        fieldMap1 = _getFieldsAndFragment2[ 0 ],
        fragmentNames1 = _getFieldsAndFragment2[ 1 ];

      var _getFieldsAndFragment3 = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType2, selectionSet2),
        fieldMap2 = _getFieldsAndFragment3[ 0 ],
        fragmentNames2 = _getFieldsAndFragment3[ 1 ];

      // (H) First, collect all conflicts between these two collections of field.

      collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap1, fieldMap2);

      // (I) Then collect conflicts between the first collection of fields and
      // those referenced by each fragment name associated with the second.
      for (var j = 0; j < fragmentNames2.length; j++) {
        collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap1, fragmentNames2[ j ]);
      }

      // (I) Then collect conflicts between the second collection of fields and
      // those referenced by each fragment name associated with the first.
      for (var i = 0; i < fragmentNames1.length; i++) {
        collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap2, fragmentNames1[ i ]);
      }

      // (J) Also collect conflicts between any fragment names by the first and
      // fragment names by the second. This compares each item in the first set of
      // names to each item in the second set of names.
      for (var _i = 0; _i < fragmentNames1.length; _i++) {
        for (var _j = 0; _j < fragmentNames2.length; _j++) {
          collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fragmentNames1[ _i ], fragmentNames2[ _j ]);
        }
      }
      return conflicts;
    }

// Collect all Conflicts "within" one collection of fields.
    function collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, fieldMap) {
      // A field map is a keyed collection, where each key represents a response
      // name and the value at that key is a list of all fields which provide that
      // response name. For every response name, if there are multiple fields, they
      // must be compared to find a potential conflict.
      Object.keys(fieldMap).forEach(function(responseName) {
        var fields = fieldMap[ responseName ];
        // This compares every field in the list to every other field in this list
        // (except to itself). If the list only has one item, nothing needs to
        // be compared.
        if (fields.length > 1) {
          for (var i = 0; i < fields.length; i++) {
            for (var j = i + 1; j < fields.length; j++) {
              var conflict = findConflict(context, cachedFieldsAndFragmentNames, comparedFragments, false, // within one collection is never mutually exclusive
                responseName, fields[ i ], fields[ j ]);
              if (conflict) {
                conflicts.push(conflict);
              }
            }
          }
        }
      });
    }

// Collect all Conflicts between two collections of fields. This is similar to,
// but different from the `collectConflictsWithin` function above. This check
// assumes that `collectConflictsWithin` has already been called on each
// provided collection of fields. This is true because this validator traverses
// each individual selection set.
    function collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, parentFieldsAreMutuallyExclusive, fieldMap1, fieldMap2) {
      // A field map is a keyed collection, where each key represents a response
      // name and the value at that key is a list of all fields which provide that
      // response name. For any response name which appears in both provided field
      // maps, each field from the first field map must be compared to every field
      // in the second field map to find potential conflicts.
      Object.keys(fieldMap1).forEach(function(responseName) {
        var fields2 = fieldMap2[ responseName ];
        if (fields2) {
          var fields1 = fieldMap1[ responseName ];
          for (var i = 0; i < fields1.length; i++) {
            for (var j = 0; j < fields2.length; j++) {
              var conflict = findConflict(context, cachedFieldsAndFragmentNames, comparedFragments, parentFieldsAreMutuallyExclusive, responseName, fields1[ i ], fields2[ j ]);
              if (conflict) {
                conflicts.push(conflict);
              }
            }
          }
        }
      });
    }

// Determines if there is a conflict between two particular fields, including
// comparing their sub-fields.
    function findConflict(context, cachedFieldsAndFragmentNames, comparedFragments, parentFieldsAreMutuallyExclusive, responseName, field1, field2) {
      var parentType1 = field1[ 0 ],
        node1 = field1[ 1 ],
        def1 = field1[ 2 ];
      var parentType2 = field2[ 0 ],
        node2 = field2[ 1 ],
        def2 = field2[ 2 ];

      // If it is known that two fields could not possibly apply at the same
      // time, due to the parent types, then it is safe to permit them to diverge
      // in aliased field or arguments used as they will not present any ambiguity
      // by differing.
      // It is known that two parent types could never overlap if they are
      // different Object types. Interface or Union types might overlap - if not
      // in the current state of the schema, then perhaps in some future version,
      // thus may not safely diverge.

      var areMutuallyExclusive = parentFieldsAreMutuallyExclusive || parentType1 !== parentType2 && parentType1 instanceof _definition.GraphQLObjectType && parentType2 instanceof _definition.GraphQLObjectType;

      // The return type for each field.
      var type1 = def1 && def1.type;
      var type2 = def2 && def2.type;

      if (!areMutuallyExclusive) {
        // Two aliases must refer to the same field.
        var name1 = node1.name.value;
        var name2 = node2.name.value;
        if (name1 !== name2) {
          return [ [ responseName, name1 + ' and ' + name2 + ' are different fields' ], [ node1 ], [ node2 ] ];
        }

        // Two field calls must have the same arguments.
        if (!sameArguments(node1.arguments || [], node2.arguments || [])) {
          return [ [ responseName, 'they have differing arguments' ], [ node1 ], [ node2 ] ];
        }
      }

      if (type1 && type2 && doTypesConflict(type1, type2)) {
        return [ [ responseName, 'they return conflicting types ' + String(type1) + ' and ' + String(type2) ], [ node1 ], [ node2 ] ];
      }

      // Collect and compare sub-fields. Use the same "visited fragment names" list
      // for both collections so fields in a fragment reference are never
      // compared to themselves.
      var selectionSet1 = node1.selectionSet;
      var selectionSet2 = node2.selectionSet;
      if (selectionSet1 && selectionSet2) {
        var conflicts = findConflictsBetweenSubSelectionSets(context, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, (0, _definition.getNamedType)(type1), selectionSet1, (0, _definition.getNamedType)(type2), selectionSet2);
        return subfieldConflicts(conflicts, responseName, node1, node2);
      }
    }

    function sameArguments(arguments1, arguments2) {
      if (arguments1.length !== arguments2.length) {
        return false;
      }
      return arguments1.every(function(argument1) {
        var argument2 = (0, _find2.default)(arguments2, function(argument) {
          return argument.name.value === argument1.name.value;
        });
        if (!argument2) {
          return false;
        }
        return sameValue(argument1.value, argument2.value);
      });
    }

    function sameValue(value1, value2) {
      return !value1 && !value2 || (0, _printer.print)(value1) === (0, _printer.print)(value2);
    }

// Two types conflict if both types could not apply to a value simultaneously.
// Composite types are ignored as their individual field types will be compared
// later recursively. However List and Non-Null types must match.
    function doTypesConflict(type1, type2) {
      if (type1 instanceof _definition.GraphQLList) {
        return type2 instanceof _definition.GraphQLList ? doTypesConflict(type1.ofType, type2.ofType) : true;
      }
      if (type2 instanceof _definition.GraphQLList) {
        return type1 instanceof _definition.GraphQLList ? doTypesConflict(type1.ofType, type2.ofType) : true;
      }
      if (type1 instanceof _definition.GraphQLNonNull) {
        return type2 instanceof _definition.GraphQLNonNull ? doTypesConflict(type1.ofType, type2.ofType) : true;
      }
      if (type2 instanceof _definition.GraphQLNonNull) {
        return type1 instanceof _definition.GraphQLNonNull ? doTypesConflict(type1.ofType, type2.ofType) : true;
      }
      if ((0, _definition.isLeafType)(type1) || (0, _definition.isLeafType)(type2)) {
        return type1 !== type2;
      }
      return false;
    }

// Given a selection set, return the collection of fields (a mapping of response
// name to field nodes and definitions) as well as a list of fragment names
// referenced via fragment spreads.
    function getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType, selectionSet) {
      var cached = cachedFieldsAndFragmentNames.get(selectionSet);
      if (!cached) {
        var nodeAndDefs = {};
        var fragmentNames = {};
        _collectFieldsAndFragmentNames(context, parentType, selectionSet, nodeAndDefs, fragmentNames);
        cached = [ nodeAndDefs, Object.keys(fragmentNames) ];
        cachedFieldsAndFragmentNames.set(selectionSet, cached);
      }
      return cached;
    }

// Given a reference to a fragment, return the represented collection of fields
// as well as a list of nested fragment names referenced via fragment spreads.
    function getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment) {
      // Short-circuit building a type from the node if possible.
      var cached = cachedFieldsAndFragmentNames.get(fragment.selectionSet);
      if (cached) {
        return cached;
      }

      var fragmentType = (0, _typeFromAST.typeFromAST)(context.getSchema(), fragment.typeCondition);
      return getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragmentType, fragment.selectionSet);
    }

    function _collectFieldsAndFragmentNames(context, parentType, selectionSet, nodeAndDefs, fragmentNames) {
      for (var i = 0; i < selectionSet.selections.length; i++) {
        var selection = selectionSet.selections[ i ];
        switch (selection.kind) {
          case _kinds.FIELD:
            var fieldName = selection.name.value;
            var fieldDef = void 0;
            if (parentType instanceof _definition.GraphQLObjectType || parentType instanceof _definition.GraphQLInterfaceType) {
              fieldDef = parentType.getFields()[ fieldName ];
            }
            var responseName = selection.alias ? selection.alias.value : fieldName;
            if (!nodeAndDefs[ responseName ]) {
              nodeAndDefs[ responseName ] = [];
            }
            nodeAndDefs[ responseName ].push([ parentType, selection, fieldDef ]);
            break;
          case _kinds.FRAGMENT_SPREAD:
            fragmentNames[ selection.name.value ] = true;
            break;
          case _kinds.INLINE_FRAGMENT:
            var typeCondition = selection.typeCondition;
            var inlineFragmentType = typeCondition ? (0, _typeFromAST.typeFromAST)(context.getSchema(), typeCondition) : parentType;
            _collectFieldsAndFragmentNames(context, inlineFragmentType, selection.selectionSet, nodeAndDefs, fragmentNames);
            break;
        }
      }
    }

// Given a series of Conflicts which occurred between two sub-fields, generate
// a single Conflict.
    function subfieldConflicts(conflicts, responseName, node1, node2) {
      if (conflicts.length > 0) {
        return [ [ responseName, conflicts.map(function(_ref3) {
          var reason = _ref3[ 0 ];
          return reason;
        }) ], conflicts.reduce(function(allFields, _ref4) {
          var fields1 = _ref4[ 1 ];
          return allFields.concat(fields1);
        }, [ node1 ]), conflicts.reduce(function(allFields, _ref5) {
          var fields2 = _ref5[ 2 ];
          return allFields.concat(fields2);
        }, [ node2 ]) ];
      }
    }

    /**
     * A way to keep track of pairs of things when the ordering of the pair does
     * not matter. We do this by maintaining a sort of double adjacency sets.
     */

    var PairSet = function() {
      function PairSet() {
        _classCallCheck(this, PairSet);

        this._data = Object.create(null);
      }

      PairSet.prototype.has = function has(a, b, areMutuallyExclusive) {
        var first = this._data[ a ];
        var result = first && first[ b ];
        if (result === undefined) {
          return false;
        }
        // areMutuallyExclusive being false is a superset of being true,
        // hence if we want to know if this PairSet "has" these two with no
        // exclusivity, we have to ensure it was added as such.
        if (areMutuallyExclusive === false) {
          return result === false;
        }
        return true;
      };

      PairSet.prototype.add = function add(a, b, areMutuallyExclusive) {
        _pairSetAdd(this._data, a, b, areMutuallyExclusive);
        _pairSetAdd(this._data, b, a, areMutuallyExclusive);
      };

      return PairSet;
    }();

    function _pairSetAdd(data, a, b, areMutuallyExclusive) {
      var map = data[ a ];
      if (!map) {
        map = Object.create(null);
        data[ a ] = map;
      }
      map[ b ] = areMutuallyExclusive;
    }

    /***/
  }),
  /* 70 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.typeIncompatibleSpreadMessage = typeIncompatibleSpreadMessage;
    exports.typeIncompatibleAnonSpreadMessage = typeIncompatibleAnonSpreadMessage;
    exports.PossibleFragmentSpreads = PossibleFragmentSpreads;

    var _error = __webpack_require__(0);

    var _typeComparators = __webpack_require__(19);

    var _typeFromAST = __webpack_require__(9);

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function typeIncompatibleSpreadMessage(fragName, parentType, fragType) {
      return 'Fragment "' + fragName + '" cannot be spread here as objects of ' + ('type "' + String(parentType) + '" can never be of type "' + String(fragType) + '".');
    }

    function typeIncompatibleAnonSpreadMessage(parentType, fragType) {
      return 'Fragment cannot be spread here as objects of ' + ('type "' + String(parentType) + '" can never be of type "' + String(fragType) + '".');
    }

    /**
     * Possible fragment spread
     *
     * A fragment spread is only valid if the type condition could ever possibly
     * be true: if there is a non-empty intersection of the possible parent types,
     * and possible types which pass the type condition.
     */
    function PossibleFragmentSpreads(context) {
      return {
        InlineFragment: function InlineFragment(node) {
          var fragType = context.getType();
          var parentType = context.getParentType();
          if (fragType && parentType && !(0, _typeComparators.doTypesOverlap)(context.getSchema(), fragType, parentType)) {
            context.reportError(new _error.GraphQLError(typeIncompatibleAnonSpreadMessage(parentType, fragType), [ node ]));
          }
        },
        FragmentSpread: function FragmentSpread(node) {
          var fragName = node.name.value;
          var fragType = getFragmentType(context, fragName);
          var parentType = context.getParentType();
          if (fragType && parentType && !(0, _typeComparators.doTypesOverlap)(context.getSchema(), fragType, parentType)) {
            context.reportError(new _error.GraphQLError(typeIncompatibleSpreadMessage(fragName, parentType, fragType), [ node ]));
          }
        }
      };
    }

    function getFragmentType(context, name) {
      var frag = context.getFragment(name);
      return frag && (0, _typeFromAST.typeFromAST)(context.getSchema(), frag.typeCondition);
    }

    /***/
  }),
  /* 71 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.missingFieldArgMessage = missingFieldArgMessage;
    exports.missingDirectiveArgMessage = missingDirectiveArgMessage;
    exports.ProvidedNonNullArguments = ProvidedNonNullArguments;

    var _error = __webpack_require__(0);

    var _keyMap = __webpack_require__(12);

    var _keyMap2 = _interopRequireDefault(_keyMap);

    var _definition = __webpack_require__(1);

    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { 'default': obj };
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function missingFieldArgMessage(fieldName, argName, type) {
      return 'Field "' + fieldName + '" argument "' + argName + '" of type ' + ('"' + String(type) + '" is required but not provided.');
    }

    function missingDirectiveArgMessage(directiveName, argName, type) {
      return 'Directive "@' + directiveName + '" argument "' + argName + '" of type ' + ('"' + String(type) + '" is required but not provided.');
    }

    /**
     * Provided required arguments
     *
     * A field or directive is only valid if all required (non-null) field arguments
     * have been provided.
     */
    function ProvidedNonNullArguments(context) {
      return {
        Field: {
          // Validate on leave to allow for deeper errors to appear first.
          leave: function leave(node) {
            var fieldDef = context.getFieldDef();
            if (!fieldDef) {
              return false;
            }
            var argNodes = node.arguments || [];

            var argNodeMap = (0, _keyMap2.default)(argNodes, function(arg) {
              return arg.name.value;
            });
            fieldDef.args.forEach(function(argDef) {
              var argNode = argNodeMap[ argDef.name ];
              if (!argNode && argDef.type instanceof _definition.GraphQLNonNull) {
                context.reportError(new _error.GraphQLError(missingFieldArgMessage(node.name.value, argDef.name, argDef.type), [ node ]));
              }
            });
          }
        },

        Directive: {
          // Validate on leave to allow for deeper errors to appear first.
          leave: function leave(node) {
            var directiveDef = context.getDirective();
            if (!directiveDef) {
              return false;
            }
            var argNodes = node.arguments || [];

            var argNodeMap = (0, _keyMap2.default)(argNodes, function(arg) {
              return arg.name.value;
            });
            directiveDef.args.forEach(function(argDef) {
              var argNode = argNodeMap[ argDef.name ];
              if (!argNode && argDef.type instanceof _definition.GraphQLNonNull) {
                context.reportError(new _error.GraphQLError(missingDirectiveArgMessage(node.name.value, argDef.name, argDef.type), [ node ]));
              }
            });
          }
        }
      };
    }

    /***/
  }),
  /* 72 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.noSubselectionAllowedMessage = noSubselectionAllowedMessage;
    exports.requiredSubselectionMessage = requiredSubselectionMessage;
    exports.ScalarLeafs = ScalarLeafs;

    var _error = __webpack_require__(0);

    var _definition = __webpack_require__(1);

    function noSubselectionAllowedMessage(fieldName, type) {
      return 'Field "' + fieldName + '" must not have a selection since ' + ('type "' + String(type) + '" has no subfields.');
    }

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function requiredSubselectionMessage(fieldName, type) {
      return 'Field "' + fieldName + '" of type "' + String(type) + '" must have a ' + ('selection of subfields. Did you mean "' + fieldName + ' { ... }"?');
    }

    /**
     * Scalar leafs
     *
     * A GraphQL document is valid only if all leaf fields (fields without
     * sub selections) are of scalar or enum types.
     */
    function ScalarLeafs(context) {
      return {
        Field: function Field(node) {
          var type = context.getType();
          if (type) {
            if ((0, _definition.isLeafType)(type)) {
              if (node.selectionSet) {
                context.reportError(new _error.GraphQLError(noSubselectionAllowedMessage(node.name.value, type), [ node.selectionSet ]));
              }
            } else if (!node.selectionSet) {
              context.reportError(new _error.GraphQLError(requiredSubselectionMessage(node.name.value, type), [ node ]));
            }
          }
        }
      };
    }

    /***/
  }),
  /* 73 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.duplicateArgMessage = duplicateArgMessage;
    exports.UniqueArgumentNames = UniqueArgumentNames;

    var _error = __webpack_require__(0);

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function duplicateArgMessage(argName) {
      return 'There can be only one argument named "' + argName + '".';
    }

    /**
     * Unique argument names
     *
     * A GraphQL field or directive is only valid if all supplied arguments are
     * uniquely named.
     */
    function UniqueArgumentNames(context) {
      var knownArgNames = Object.create(null);
      return {
        Field:     function Field() {
          knownArgNames = Object.create(null);
        },
        Directive: function Directive() {
          knownArgNames = Object.create(null);
        },
        Argument:  function Argument(node) {
          var argName = node.name.value;
          if (knownArgNames[ argName ]) {
            context.reportError(new _error.GraphQLError(duplicateArgMessage(argName), [ knownArgNames[ argName ], node.name ]));
          } else {
            knownArgNames[ argName ] = node.name;
          }
          return false;
        }
      };
    }

    /***/
  }),
  /* 74 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.duplicateDirectiveMessage = duplicateDirectiveMessage;
    exports.UniqueDirectivesPerLocation = UniqueDirectivesPerLocation;

    var _error = __webpack_require__(0);

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function duplicateDirectiveMessage(directiveName) {
      return 'The directive "' + directiveName + '" can only be used once at ' + 'this location.';
    }

    /**
     * Unique directive names per location
     *
     * A GraphQL document is only valid if all directives at a given location
     * are uniquely named.
     */
    function UniqueDirectivesPerLocation(context) {
      return {
        // Many different AST nodes may contain directives. Rather than listing
        // them all, just listen for entering any node, and check to see if it
        // defines any directives.
        enter: function enter(node) {
          if (node.directives) {
            (function() {
              var knownDirectives = Object.create(null);
              node.directives.forEach(function(directive) {
                var directiveName = directive.name.value;
                if (knownDirectives[ directiveName ]) {
                  context.reportError(new _error.GraphQLError(duplicateDirectiveMessage(directiveName), [ knownDirectives[ directiveName ], directive ]));
                } else {
                  knownDirectives[ directiveName ] = directive;
                }
              });
            })();
          }
        }
      };
    }

    /***/
  }),
  /* 75 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.duplicateFragmentNameMessage = duplicateFragmentNameMessage;
    exports.UniqueFragmentNames = UniqueFragmentNames;

    var _error = __webpack_require__(0);

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function duplicateFragmentNameMessage(fragName) {
      return 'There can only be one fragment named "' + fragName + '".';
    }

    /**
     * Unique fragment names
     *
     * A GraphQL document is only valid if all defined fragments have unique names.
     */
    function UniqueFragmentNames(context) {
      var knownFragmentNames = Object.create(null);
      return {
        OperationDefinition: function OperationDefinition() {
          return false;
        },
        FragmentDefinition:  function FragmentDefinition(node) {
          var fragmentName = node.name.value;
          if (knownFragmentNames[ fragmentName ]) {
            context.reportError(new _error.GraphQLError(duplicateFragmentNameMessage(fragmentName), [ knownFragmentNames[ fragmentName ], node.name ]));
          } else {
            knownFragmentNames[ fragmentName ] = node.name;
          }
          return false;
        }
      };
    }

    /***/
  }),
  /* 76 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.duplicateInputFieldMessage = duplicateInputFieldMessage;
    exports.UniqueInputFieldNames = UniqueInputFieldNames;

    var _error = __webpack_require__(0);

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function duplicateInputFieldMessage(fieldName) {
      return 'There can be only one input field named "' + fieldName + '".';
    }

    /**
     * Unique input field names
     *
     * A GraphQL input object value is only valid if all supplied fields are
     * uniquely named.
     */
    function UniqueInputFieldNames(context) {
      var knownNameStack = [];
      var knownNames = Object.create(null);

      return {
        ObjectValue: {
          enter: function enter() {
            knownNameStack.push(knownNames);
            knownNames = Object.create(null);
          },
          leave: function leave() {
            knownNames = knownNameStack.pop();
          }
        },
        ObjectField: function ObjectField(node) {
          var fieldName = node.name.value;
          if (knownNames[ fieldName ]) {
            context.reportError(new _error.GraphQLError(duplicateInputFieldMessage(fieldName), [ knownNames[ fieldName ], node.name ]));
          } else {
            knownNames[ fieldName ] = node.name;
          }
          return false;
        }
      };
    }

    /***/
  }),
  /* 77 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.duplicateOperationNameMessage = duplicateOperationNameMessage;
    exports.UniqueOperationNames = UniqueOperationNames;

    var _error = __webpack_require__(0);

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function duplicateOperationNameMessage(operationName) {
      return 'There can only be one operation named "' + operationName + '".';
    }

    /**
     * Unique operation names
     *
     * A GraphQL document is only valid if all defined operations have unique names.
     */
    function UniqueOperationNames(context) {
      var knownOperationNames = Object.create(null);
      return {
        OperationDefinition: function OperationDefinition(node) {
          var operationName = node.name;
          if (operationName) {
            if (knownOperationNames[ operationName.value ]) {
              context.reportError(new _error.GraphQLError(duplicateOperationNameMessage(operationName.value), [ knownOperationNames[ operationName.value ], operationName ]));
            } else {
              knownOperationNames[ operationName.value ] = operationName;
            }
          }
          return false;
        },

        FragmentDefinition: function FragmentDefinition() {
          return false;
        }
      };
    }

    /***/
  }),
  /* 78 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.duplicateVariableMessage = duplicateVariableMessage;
    exports.UniqueVariableNames = UniqueVariableNames;

    var _error = __webpack_require__(0);

    function duplicateVariableMessage(variableName) {
      return 'There can be only one variable named "' + variableName + '".';
    }

    /**
     * Unique variable names
     *
     * A GraphQL operation is only valid if all its variables are uniquely named.
     */

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function UniqueVariableNames(context) {
      var knownVariableNames = Object.create(null);
      return {
        OperationDefinition: function OperationDefinition() {
          knownVariableNames = Object.create(null);
        },
        VariableDefinition:  function VariableDefinition(node) {
          var variableName = node.variable.name.value;
          if (knownVariableNames[ variableName ]) {
            context.reportError(new _error.GraphQLError(duplicateVariableMessage(variableName), [ knownVariableNames[ variableName ], node.variable.name ]));
          } else {
            knownVariableNames[ variableName ] = node.variable.name;
          }
        }
      };
    }

    /***/
  }),
  /* 79 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.nonInputTypeOnVarMessage = nonInputTypeOnVarMessage;
    exports.VariablesAreInputTypes = VariablesAreInputTypes;

    var _error = __webpack_require__(0);

    var _printer = __webpack_require__(4);

    var _definition = __webpack_require__(1);

    var _typeFromAST = __webpack_require__(9);

    function nonInputTypeOnVarMessage(variableName, typeName) {
      return 'Variable "$' + variableName + '" cannot be non-input type "' + typeName + '".';
    }

    /**
     * Variables are input types
     *
     * A GraphQL operation is only valid if all the variables it defines are of
     * input types (scalar, enum, or input object).
     */

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function VariablesAreInputTypes(context) {
      return {
        VariableDefinition: function VariableDefinition(node) {
          var type = (0, _typeFromAST.typeFromAST)(context.getSchema(), node.type);

          // If the variable type is not an input type, return an error.
          if (type && !(0, _definition.isInputType)(type)) {
            var variableName = node.variable.name.value;
            context.reportError(new _error.GraphQLError(nonInputTypeOnVarMessage(variableName, (0, _printer.print)(node.type)), [ node.type ]));
          }
        }
      };
    }

    /***/
  }),
  /* 80 */
  /***/ (function(module, exports, __webpack_require__) {

    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.badVarPosMessage = badVarPosMessage;
    exports.VariablesInAllowedPosition = VariablesInAllowedPosition;

    var _error = __webpack_require__(0);

    var _definition = __webpack_require__(1);

    var _typeComparators = __webpack_require__(19);

    var _typeFromAST = __webpack_require__(9);

    function badVarPosMessage(varName, varType, expectedType) {
      return 'Variable "$' + varName + '" of type "' + String(varType) + '" used in ' + ('position expecting type "' + String(expectedType) + '".');
    }

    /**
     * Variables passed to field arguments conform to type
     */

    /**
     *  Copyright (c) 2015, Facebook, Inc.
     *  All rights reserved.
     *
     *  This source code is licensed under the BSD-style license found in the
     *  LICENSE file in the root directory of this source tree. An additional grant
     *  of patent rights can be found in the PATENTS file in the same directory.
     */

    function VariablesInAllowedPosition(context) {
      var varDefMap = Object.create(null);

      return {
        OperationDefinition: {
          enter: function enter() {
            varDefMap = Object.create(null);
          },
          leave: function leave(operation) {
            var usages = context.getRecursiveVariableUsages(operation);

            usages.forEach(function(_ref) {
              var node = _ref.node,
                type = _ref.type;

              var varName = node.name.value;
              var varDef = varDefMap[ varName ];
              if (varDef && type) {
                // A var type is allowed if it is the same or more strict (e.g. is
                // a subtype of) than the expected type. It can be more strict if
                // the variable type is non-null when the expected type is nullable.
                // If both are list types, the variable item type can be more strict
                // than the expected item type (contravariant).
                var schema = context.getSchema();
                var varType = (0, _typeFromAST.typeFromAST)(schema, varDef.type);
                if (varType && !(0, _typeComparators.isTypeSubTypeOf)(schema, effectiveType(varType, varDef), type)) {
                  context.reportError(new _error.GraphQLError(badVarPosMessage(varName, varType, type), [ varDef, node ]));
                }
              }
            });
          }
        },
        VariableDefinition:  function VariableDefinition(node) {
          varDefMap[ node.variable.name.value ] = node;
        }
      };
    }

// If a variable definition has a default value, it's effectively non-null.
    function effectiveType(varType, varDef) {
      return !varDef.defaultValue || varType instanceof _definition.GraphQLNonNull ? varType : new _definition.GraphQLNonNull(varType);
    }

    /***/
  })
  /******/ ]);